FileDocCategorySizeDatePackage
PrintWriter.javaAPI DocJava SE 5 API33658Fri Aug 26 14:57:00 BST 2005java.io

PrintWriter

public class PrintWriter extends Writer
Print formatted representations of objects to a text-output stream. This class implements all of the print methods found in {@link PrintStream}. It does not contain methods for writing raw bytes, for which a program should use unencoded byte streams.

Unlike the {@link PrintStream} class, if automatic flushing is enabled it will be done only when one of the println, printf, or format methods is invoked, rather than whenever a newline character happens to be output. These methods use the platform's own notion of line separator rather than the newline character.

Methods in this class never throw I/O exceptions, although some of its constructors may. The client may inquire as to whether any errors have occurred by invoking {@link #checkError checkError()}.

version
1.37, 07/16/04
author
Frank Yellin
author
Mark Reinhold
since
JDK1.1

Fields Summary
protected Writer
out
The underlying character-output stream of this PrintWriter.
private boolean
autoFlush
private boolean
trouble
private Formatter
formatter
private String
lineSeparator
Line separator string. This is the value of the line.separator property at the moment that the stream was created.
Constructors Summary
public PrintWriter(Writer out)
Create a new PrintWriter, without automatic line flushing.

param
out A character-output stream


                              
        
	this(out, false);
    
public PrintWriter(Writer out, boolean autoFlush)
Create a new PrintWriter.

param
out A character-output stream
param
autoFlush A boolean; if true, the println, printf, or format methods will flush the output buffer

	super(out);
	this.out = out;
	this.autoFlush = autoFlush;
	lineSeparator = (String) java.security.AccessController.doPrivileged(
               new sun.security.action.GetPropertyAction("line.separator"));
    
public PrintWriter(OutputStream out)
Create a new PrintWriter, without automatic line flushing, from an existing OutputStream. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will convert characters into bytes using the default character encoding.

param
out An output stream
see
java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)

	this(out, false);
    
public PrintWriter(OutputStream out, boolean autoFlush)
Create a new PrintWriter from an existing OutputStream. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will convert characters into bytes using the default character encoding.

param
out An output stream
param
autoFlush A boolean; if true, the println, printf, or format methods will flush the output buffer
see
java.io.OutputStreamWriter#OutputStreamWriter(java.io.OutputStream)

	this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);
    
public PrintWriter(String fileName)
Creates a new PrintWriter, without automatic line flushing, with the specified file name. This convenience constructor creates the necessary intermediate {@link java.io.OutputStreamWriter OutputStreamWriter}, which will encode characters using the {@linkplain java.nio.charset.Charset#defaultCharset default charset} for this instance of the Java virtual machine.

param
fileName The name of the file to use as the destination of this writer. If the file exists then it will be truncated to zero size; otherwise, a new file will be created. The output will be written to the file and is buffered.
throws
FileNotFoundException If the given string does not denote an existing, writable regular file and a new regular file of that name cannot be created, or if some other error occurs while opening or creating the file
throws
SecurityException If a security manager is present and {@link SecurityManager#checkWrite checkWrite(fileName)} denies write access to the file
since
1.5

	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
	     false);
    
public PrintWriter(String fileName, String csn)
Creates a new PrintWriter, without automatic line flushing, with the specified file name and charset. This convenience constructor creates the necessary intermediate {@link java.io.OutputStreamWriter OutputStreamWriter}, which will encode characters using the provided charset.

param
fileName The name of the file to use as the destination of this writer. If the file exists then it will be truncated to zero size; otherwise, a new file will be created. The output will be written to the file and is buffered.
param
csn The name of a supported {@linkplain java.nio.charset.Charset charset}
throws
FileNotFoundException If the given string does not denote an existing, writable regular file and a new regular file of that name cannot be created, or if some other error occurs while opening or creating the file
throws
SecurityException If a security manager is present and {@link SecurityManager#checkWrite checkWrite(fileName)} denies write access to the file
throws
UnsupportedEncodingException If the named charset is not supported
since
1.5

	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), csn)),
	     false);
    
public PrintWriter(File file)
Creates a new PrintWriter, without automatic line flushing, with the specified file. This convenience constructor creates the necessary intermediate {@link java.io.OutputStreamWriter OutputStreamWriter}, which will encode characters using the {@linkplain java.nio.charset.Charset#defaultCharset default charset} for this instance of the Java virtual machine.

param
file The file to use as the destination of this writer. If the file exists then it will be truncated to zero size; otherwise, a new file will be created. The output will be written to the file and is buffered.
throws
FileNotFoundException If the given file object does not denote an existing, writable regular file and a new regular file of that name cannot be created, or if some other error occurs while opening or creating the file
throws
SecurityException If a security manager is present and {@link SecurityManager#checkWrite checkWrite(file.getPath())} denies write access to the file
since
1.5

	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),
	     false);
    
public PrintWriter(File file, String csn)
Creates a new PrintWriter, without automatic line flushing, with the specified file and charset. This convenience constructor creates the necessary intermediate {@link java.io.OutputStreamWriter OutputStreamWriter}, which will encode characters using the provided charset.

param
file The file to use as the destination of this writer. If the file exists then it will be truncated to zero size; otherwise, a new file will be created. The output will be written to the file and is buffered.
param
csn The name of a supported {@linkplain java.nio.charset.Charset charset}
throws
FileNotFoundException If the given file object does not denote an existing, writable regular file and a new regular file of that name cannot be created, or if some other error occurs while opening or creating the file
throws
SecurityException If a security manager is present and {@link SecurityManager#checkWrite checkWrite(file.getPath())} denies write access to the file
throws
UnsupportedEncodingException If the named charset is not supported
since
1.5

	this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), csn)),
	     false);
    
Methods Summary
public java.io.PrintWriterappend(java.lang.CharSequence csq)
Appends the specified character sequence to this writer.

An invocation of this method of the form out.append(csq) behaves in exactly the same way as the invocation

out.write(csq.toString()) 

Depending on the specification of toString for the character sequence csq, the entire sequence may not be appended. For instance, invoking the toString method of a character buffer will return a subsequence whose content depends upon the buffer's position and limit.

param
csq The character sequence to append. If csq is null, then the four characters "null" are appended to this writer.
return
This writer
since
1.5

	if (csq == null)
	    write("null");
	else
	    write(csq.toString());
    	return this;
    
public java.io.PrintWriterappend(java.lang.CharSequence csq, int start, int end)
Appends a subsequence of the specified character sequence to this writer.

An invocation of this method of the form out.append(csq, start, end) when csq is not null, behaves in exactly the same way as the invocation

out.write(csq.subSequence(start, end).toString()) 

param
csq The character sequence from which a subsequence will be appended. If csq is null, then characters will be appended as if csq contained the four characters "null".
param
start The index of the first character in the subsequence
param
end The index of the character following the last character in the subsequence
return
This writer
throws
IndexOutOfBoundsException If start or end are negative, start is greater than end, or end is greater than csq.length()
since
1.5

	CharSequence cs = (csq == null ? "null" : csq);
	write(cs.subSequence(start, end).toString());
    	return this;
    
public java.io.PrintWriterappend(char c)
Appends the specified character to this writer.

An invocation of this method of the form out.append(c) behaves in exactly the same way as the invocation

out.write(c) 

param
c The 16-bit character to append
return
This writer
since
1.5

	write(c);
	return this;
    
public booleancheckError()
Flush the stream if it's not closed and check its error state. Errors are cumulative; once the stream encounters an error, this routine will return true on all successive calls.

return
True if the print stream has encountered an error, either on the underlying output stream or during a format conversion.

	if (out != null)
	    flush();
	return trouble;
    
public voidclose()
Close the stream.

see
#checkError()

	try {
	    synchronized (lock) {
		if (out == null)
		    return;
		out.close();
		out = null;
	    }
	}
	catch (IOException x) {
	    trouble = true;
	}
    
private voidensureOpen()
Check to make sure that the stream has not been closed

	if (out == null)
	    throw new IOException("Stream closed");
    
public voidflush()
Flush the stream.

see
#checkError()

	try {
	    synchronized (lock) {
		ensureOpen();
		out.flush();
	    }
	}
	catch (IOException x) {
	    trouble = true;
	}
    
public java.io.PrintWriterformat(java.lang.String format, java.lang.Object args)
Writes a formatted string to this writer using the specified format string and arguments. If automatic flushing is enabled, calls to this method will flush the output buffer.

The locale always used is the one returned by {@link java.util.Locale#getDefault() Locale.getDefault()}, regardless of any previous invocations of other formatting methods on this object.

param
format A format string as described in Format string syntax.
param
args Arguments referenced by the format specifiers in the format string. If there are more arguments than format specifiers, the extra arguments are ignored. The number of arguments is variable and may be zero. The maximum number of arguments is limited by the maximum dimension of a Java array as defined by the Java Virtual Machine Specification. The behaviour on a null argument depends on the conversion.
throws
IllegalFormatException If a format string contains an illegal syntax, a format specifier that is incompatible with the given arguments, insufficient arguments given the format string, or other illegal conditions. For specification of all possible formatting errors, see the Details section of the Formatter class specification.
throws
NullPointerException If the format is null
return
This writer
since
1.5

	try {
	    synchronized (lock) {
		ensureOpen();
		if ((formatter == null)
		    || (formatter.locale() != Locale.getDefault()))
		    formatter = new Formatter(this);
		formatter.format(Locale.getDefault(), format, args);
		if (autoFlush)
		    out.flush();
	    }
	} catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	} catch (IOException x) {
	    trouble = true;
	}
	return this;
    
public java.io.PrintWriterformat(java.util.Locale l, java.lang.String format, java.lang.Object args)
Writes a formatted string to this writer using the specified format string and arguments. If automatic flushing is enabled, calls to this method will flush the output buffer.

param
l The {@linkplain java.util.Locale locale} to apply during formatting. If l is null then no localization is applied.
param
format A format string as described in Format string syntax.
param
args Arguments referenced by the format specifiers in the format string. If there are more arguments than format specifiers, the extra arguments are ignored. The number of arguments is variable and may be zero. The maximum number of arguments is limited by the maximum dimension of a Java array as defined by the Java Virtual Machine Specification. The behaviour on a null argument depends on the conversion.
throws
IllegalFormatException If a format string contains an illegal syntax, a format specifier that is incompatible with the given arguments, insufficient arguments given the format string, or other illegal conditions. For specification of all possible formatting errors, see the Details section of the formatter class specification.
throws
NullPointerException If the format is null
return
This writer
since
1.5

	try {
	    synchronized (lock) {
		ensureOpen();
		if ((formatter == null) || (formatter.locale() != l))
		    formatter = new Formatter(this, l);
		formatter.format(l, format, args);
		if (autoFlush)
		    out.flush();
	    }
	} catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	} catch (IOException x) {
	    trouble = true;
	}
	return this;
    
private voidnewLine()

	try {
	    synchronized (lock) {
		ensureOpen();
		out.write(lineSeparator);
		if (autoFlush)
		    out.flush();
	    }
	}
	catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	}
	catch (IOException x) {
	    trouble = true;
	}
    
public voidprint(boolean b)
Print a boolean value. The string produced by {@link java.lang.String#valueOf(boolean)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
b The boolean to be printed

	write(b ? "true" : "false");
    
public voidprint(char c)
Print a character. The character is translated into one or more bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
c The char to be printed

	write(c);
    
public voidprint(int i)
Print an integer. The string produced by {@link java.lang.String#valueOf(int)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
i The int to be printed
see
java.lang.Integer#toString(int)

	write(String.valueOf(i));
    
public voidprint(long l)
Print a long integer. The string produced by {@link java.lang.String#valueOf(long)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
l The long to be printed
see
java.lang.Long#toString(long)

	write(String.valueOf(l));
    
public voidprint(float f)
Print a floating-point number. The string produced by {@link java.lang.String#valueOf(float)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
f The float to be printed
see
java.lang.Float#toString(float)

	write(String.valueOf(f));
    
public voidprint(double d)
Print a double-precision floating-point number. The string produced by {@link java.lang.String#valueOf(double)} is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
d The double to be printed
see
java.lang.Double#toString(double)

	write(String.valueOf(d));
    
public voidprint(char[] s)
Print an array of characters. The characters are converted into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
s The array of chars to be printed
throws
NullPointerException If s is null

	write(s);
    
public voidprint(java.lang.String s)
Print a string. If the argument is null then the string "null" is printed. Otherwise, the string's characters are converted into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
s The String to be printed

	if (s == null) {
	    s = "null";
	}
	write(s);
    
public voidprint(java.lang.Object obj)
Print an object. The string produced by the {@link java.lang.String#valueOf(Object)} method is translated into bytes according to the platform's default character encoding, and these bytes are written in exactly the manner of the {@link #write(int)} method.

param
obj The Object to be printed
see
java.lang.Object#toString()

	write(String.valueOf(obj));
    
public java.io.PrintWriterprintf(java.lang.String format, java.lang.Object args)
A convenience method to write a formatted string to this writer using the specified format string and arguments. If automatic flushing is enabled, calls to this method will flush the output buffer.

An invocation of this method of the form out.printf(format, args) behaves in exactly the same way as the invocation

out.format(format, args) 

param
format A format string as described in Format string syntax.
param
args Arguments referenced by the format specifiers in the format string. If there are more arguments than format specifiers, the extra arguments are ignored. The number of arguments is variable and may be zero. The maximum number of arguments is limited by the maximum dimension of a Java array as defined by the Java Virtual Machine Specification. The behaviour on a null argument depends on the conversion.
throws
IllegalFormatException If a format string contains an illegal syntax, a format specifier that is incompatible with the given arguments, insufficient arguments given the format string, or other illegal conditions. For specification of all possible formatting errors, see the Details section of the formatter class specification.
throws
NullPointerException If the format is null
return
This writer
since
1.5

	return format(format, args);
    
public java.io.PrintWriterprintf(java.util.Locale l, java.lang.String format, java.lang.Object args)
A convenience method to write a formatted string to this writer using the specified format string and arguments. If automatic flushing is enabled, calls to this method will flush the output buffer.

An invocation of this method of the form out.printf(l, format, args) behaves in exactly the same way as the invocation

out.format(l, format, args) 

param
l The {@linkplain java.util.Locale locale} to apply during formatting. If l is null then no localization is applied.
param
format A format string as described in Format string syntax.
param
args Arguments referenced by the format specifiers in the format string. If there are more arguments than format specifiers, the extra arguments are ignored. The number of arguments is variable and may be zero. The maximum number of arguments is limited by the maximum dimension of a Java array as defined by the Java Virtual Machine Specification. The behaviour on a null argument depends on the conversion.
throws
IllegalFormatException If a format string contains an illegal syntax, a format specifier that is incompatible with the given arguments, insufficient arguments given the format string, or other illegal conditions. For specification of all possible formatting errors, see the Details section of the formatter class specification.
throws
NullPointerException If the format is null
return
This writer
since
1.5

	return format(l, format, args);
    
public voidprintln()
Terminate the current line by writing the line separator string. The line separator string is defined by the system property line.separator, and is not necessarily a single newline character ('\n').

	newLine();
    
public voidprintln(boolean x)
Print a boolean value and then terminate the line. This method behaves as though it invokes {@link #print(boolean)} and then {@link #println()}.

param
x the boolean value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(char x)
Print a character and then terminate the line. This method behaves as though it invokes {@link #print(char)} and then {@link #println()}.

param
x the char value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(int x)
Print an integer and then terminate the line. This method behaves as though it invokes {@link #print(int)} and then {@link #println()}.

param
x the int value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(long x)
Print a long integer and then terminate the line. This method behaves as though it invokes {@link #print(long)} and then {@link #println()}.

param
x the long value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(float x)
Print a floating-point number and then terminate the line. This method behaves as though it invokes {@link #print(float)} and then {@link #println()}.

param
x the float value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(double x)
Print a double-precision floating-point number and then terminate the line. This method behaves as though it invokes {@link #print(double)} and then {@link #println()}.

param
x the double value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(char[] x)
Print an array of characters and then terminate the line. This method behaves as though it invokes {@link #print(char[])} and then {@link #println()}.

param
x the array of char values to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(java.lang.String x)
Print a String and then terminate the line. This method behaves as though it invokes {@link #print(String)} and then {@link #println()}.

param
x the String value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
public voidprintln(java.lang.Object x)
Print an Object and then terminate the line. This method behaves as though it invokes {@link #print(Object)} and then {@link #println()}.

param
x the Object value to be printed

	synchronized (lock) {
	    print(x);
	    println();
	}
    
protected voidsetError()
Indicate that an error has occurred.

	trouble = true;
	try {
	    throw new IOException();
	} catch (IOException x) {
	}
    
public voidwrite(int c)
Write a single character.

param
c int specifying a character to be written.

	try {
	    synchronized (lock) {
		ensureOpen();
		out.write(c);
	    }
	}
	catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	}
	catch (IOException x) {
	    trouble = true;
	}
    
public voidwrite(char[] buf, int off, int len)
Write A Portion of an array of characters.

param
buf Array of characters
param
off Offset from which to start writing characters
param
len Number of characters to write

	try {
	    synchronized (lock) {
		ensureOpen();
		out.write(buf, off, len);
	    }
	}
	catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	}
	catch (IOException x) {
	    trouble = true;
	}
    
public voidwrite(char[] buf)
Write an array of characters. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

param
buf Array of characters to be written

	write(buf, 0, buf.length);
    
public voidwrite(java.lang.String s, int off, int len)
Write a portion of a string.

param
s A String
param
off Offset from which to start writing characters
param
len Number of characters to write

	try {
	    synchronized (lock) {
		ensureOpen();
		out.write(s, off, len);
	    }
	}
	catch (InterruptedIOException x) {
	    Thread.currentThread().interrupt();
	}
	catch (IOException x) {
	    trouble = true;
	}
    
public voidwrite(java.lang.String s)
Write a string. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

param
s String to be written

	write(s, 0, s.length());