Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
3
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4
    *
5
    * This code is free software; you can redistribute it and/or modify it
6
    * under the terms of the GNU General Public License version 2 only, as
7
    * published by the Free Software Foundation.  Oracle designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Oracle in the LICENSE file that accompanied this code.
10
   *
11
   * This code is distributed in the hope that it will be useful, but WITHOUT
12
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
   * version 2 for more details (a copy is included in the LICENSE file that
15
   * accompanied this code).
16
   *
17
   * You should have received a copy of the GNU General Public License version
18
   * 2 along with this work; if not, write to the Free Software Foundation,
19
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20
   *
21
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22
   * or visit www.oracle.com if you need additional information or have any
23
   * questions.
24
   */
25
  
26
  package java.io;
27
  
28
  import java.util.Objects;
30
  import java.util.Locale;
Prints formatted representations of objects to a text-output stream. This class implements all of the print methods found in PrintStream. It does not contain methods for writing raw bytes, for which a program should use unencoded byte streams.

Unlike the 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 checkError().

Author(s):
Frank Yellin
Mark Reinhold
Since:
JDK1.1
54
  
55
  
56
  public class PrintWriter extends Writer {

    
The underlying character-output stream of this PrintWriter.

Since:
1.2
63
  
64
      protected Writer out;
65
  
66
      private final boolean autoFlush;
67
      private boolean trouble = false;
68
      private Formatter formatter;
69
      private PrintStream psOut = null;

    
Line separator string. This is the value of the line.separator property at the moment that the stream was created. 
74
  
75
      private final String lineSeparator;

    
Returns a charset object for the given charset name.

Throws:
java.lang.NullPointerException is csn is null
UnsupportedEncodingException if the charset is not supported
81
  
82
      private static Charset toCharset(String csn)
83
          throws UnsupportedEncodingException
84
      {
85
          Objects.requireNonNull(csn, "charsetName");
86
          try {
87
              return Charset.forName(csn);
88
          } catch (IllegalCharsetNameException|UnsupportedCharsetException unused) {
89
              // UnsupportedEncodingException should be thrown
90
              throw new UnsupportedEncodingException(csn);
91
          }
92
      }

    
Creates a new PrintWriter, without automatic line flushing.

Parameters:
out A character-output stream
98
  
99
      public PrintWriter (Writer out) {
100
         this(out, false);
101
     }

    
Creates a new PrintWriter.

Parameters:
out A character-output stream
autoFlush A boolean; if true, the println, printf, or format methods will flush the output buffer
110
 
111
     public PrintWriter(Writer out,
112
                        boolean autoFlush) {
113
         super(out);
114
         this. = out;
115
         this. = autoFlush;
116
          = java.security.AccessController.doPrivileged(
117
             new sun.security.action.GetPropertyAction("line.separator"));
118
     }

    
Creates 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.

Parameters:
out An output stream
See also:
java.io.OutputStreamWriter.OutputStreamWriter.(java.io.OutputStream)
129
 
130
     public PrintWriter(OutputStream out) {
131
         this(out, false);
132
     }

    
Creates 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.

Parameters:
out An output stream
autoFlush A boolean; if true, the println, printf, or format methods will flush the output buffer
See also:
java.io.OutputStreamWriter.OutputStreamWriter.(java.io.OutputStream)
146
 
147
     public PrintWriter(OutputStream out, boolean autoFlush) {
148
         this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);
149
 
150
         // save print stream for error propagation
151
         if (out instanceof java.io.PrintStream) {
152
              = (PrintStream) out;
153
         }
154
     }

    
Creates a new PrintWriter, without automatic line flushing, with the specified file name. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will encode characters using the java.nio.charset.Charset.defaultCharset() for this instance of the Java virtual machine.

Parameters:
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
java.lang.SecurityException If a security manager is present and java.lang.SecurityManager.checkWrite(java.io.FileDescriptor) denies write access to the file
Since:
1.5
182
 
183
     public PrintWriter(String fileName) throws FileNotFoundException {
184
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
185
              false);
186
     }
187
 
188
     /* Private constructor */
189
     private PrintWriter(Charset charset, File file)
190
         throws FileNotFoundException
191
     {
192
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), charset)),
193
              false);
194
     }

    
Creates a new PrintWriter, without automatic line flushing, with the specified file name and charset. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will encode characters using the provided charset.

Parameters:
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.
csn The name of a supported 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
java.lang.SecurityException If a security manager is present and java.lang.SecurityManager.checkWrite(java.io.FileDescriptor) denies write access to the file
UnsupportedEncodingException If the named charset is not supported
Since:
1.5
228
 
229
     public PrintWriter(String fileName, String csn)
231
     {
232
         this(toCharset(csn), new File(fileName));
233
     }

    
Creates a new PrintWriter, without automatic line flushing, with the specified file. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will encode characters using the java.nio.charset.Charset.defaultCharset() for this instance of the Java virtual machine.

Parameters:
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
java.lang.SecurityException If a security manager is present and java.lang.SecurityManager.checkWrite(java.io.FileDescriptor) denies write access to the file
Since:
1.5
261
 
262
     public PrintWriter(File file) throws FileNotFoundException {
263
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),
264
              false);
265
     }

    
Creates a new PrintWriter, without automatic line flushing, with the specified file and charset. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will encode characters using the provided charset.

Parameters:
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.
csn The name of a supported 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
java.lang.SecurityException If a security manager is present and java.lang.SecurityManager.checkWrite(java.io.FileDescriptor) denies write access to the file
UnsupportedEncodingException If the named charset is not supported
Since:
1.5
299
 
300
     public PrintWriter(File file, String csn)
302
     {
303
         this(toCharset(csn), file);
304
     }

    
Checks to make sure that the stream has not been closed
306
 
307
     private void ensureOpen() throws IOException {
308
         if ( == null)
309
             throw new IOException("Stream closed");
310
     }

    
Flushes the stream.

See also:
checkError()
315
 
316
     public void flush() {
317
         try {
318
             synchronized () {
319
                 ensureOpen();
320
                 .flush();
321
             }
322
         }
323
         catch (IOException x) {
324
              = true;
325
         }
326
     }

    
Closes the stream and releases any system resources associated with it. Closing a previously closed stream has no effect.

See also:
checkError()
333
 
334
     public void close() {
335
         try {
336
             synchronized () {
337
                 if ( == null)
338
                     return;
339
                 .close();
340
                  = null;
341
             }
342
         }
343
         catch (IOException x) {
344
              = true;
345
         }
346
     }

    
Flushes the stream if it's not closed and checks its error state.

Returns:
true if the print stream has encountered an error, either on the underlying output stream or during a format conversion.
354
 
355
     public boolean checkError() {
356
         if ( != null) {
357
             flush();
358
         }
359
         if ( instanceof java.io.PrintWriter) {
360
             PrintWriter pw = (PrintWriter) ;
361
             return pw.checkError();
362
         } else if ( != null) {
363
             return .checkError();
364
         }
365
         return ;
366
     }

    
Indicates that an error has occurred.

This method will cause subsequent invocations of checkError() to return true until clearError() is invoked. 

374
 
375
     protected void setError() {
376
          = true;
377
     }

    
Clears the error state of this stream.

This method will cause subsequent invocations of checkError() to return false until another write operation fails and invokes setError().

Since:
1.6
387
 
388
     protected void clearError() {
389
          = false;
390
     }
391
 
392
     /*
393
      * Exception-catching, synchronized output operations,
394
      * which also implement the write() methods of Writer
395
      */

    
Writes a single character.

Parameters:
c int specifying a character to be written.
400
 
401
     public void write(int c) {
402
         try {
403
             synchronized () {
404
                 ensureOpen();
405
                 .write(c);
406
             }
407
         }
408
         catch (InterruptedIOException x) {
409
             Thread.currentThread().interrupt();
410
         }
411
         catch (IOException x) {
412
              = true;
413
         }
414
     }

    
Writes A Portion of an array of characters.

Parameters:
buf Array of characters
off Offset from which to start writing characters
len Number of characters to write
421
 
422
     public void write(char buf[], int off, int len) {
423
         try {
424
             synchronized () {
425
                 ensureOpen();
426
                 .write(buf, off, len);
427
             }
428
         }
429
         catch (InterruptedIOException x) {
430
             Thread.currentThread().interrupt();
431
         }
432
         catch (IOException x) {
433
              = true;
434
         }
435
     }

    
Writes an array of characters. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

Parameters:
buf Array of characters to be written
441
 
442
     public void write(char buf[]) {
443
         write(buf, 0, buf.length);
444
     }

    
Writes a portion of a string.

Parameters:
s A String
off Offset from which to start writing characters
len Number of characters to write
451
 
452
     public void write(String s, int off, int len) {
453
         try {
454
             synchronized () {
455
                 ensureOpen();
456
                 .write(s, off, len);
457
             }
458
         }
459
         catch (InterruptedIOException x) {
460
             Thread.currentThread().interrupt();
461
         }
462
         catch (IOException x) {
463
              = true;
464
         }
465
     }

    
Writes a string. This method cannot be inherited from the Writer class because it must suppress I/O exceptions.

Parameters:
s String to be written
471
 
472
     public void write(String s) {
473
         write(s, 0, s.length());
474
     }
475
 
476
     private void newLine() {
477
         try {
478
             synchronized () {
479
                 ensureOpen();
480
                 .write();
481
                 if ()
482
                     .flush();
483
             }
484
         }
485
         catch (InterruptedIOException x) {
486
             Thread.currentThread().interrupt();
487
         }
488
         catch (IOException x) {
489
              = true;
490
         }
491
     }
492
 
493
     /* Methods that do not terminate lines */

    
Prints a boolean value. The string produced by 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 write(int) method.

Parameters:
b The boolean to be printed
503
 
504
     public void print(boolean b) {
505
         write(b ? "true" : "false");
506
     }

    
Prints 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 write(int) method.

Parameters:
c The char to be printed
515
 
516
     public void print(char c) {
517
         write(c);
518
     }

    
Prints an integer. The string produced by 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 write(int) method.

Parameters:
i The int to be printed
See also:
java.lang.Integer.toString(int)
529
 
530
     public void print(int i) {
531
         write(String.valueOf(i));
532
     }

    
Prints a long integer. The string produced by 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 write(int) method.

Parameters:
l The long to be printed
See also:
java.lang.Long.toString(long)
543
 
544
     public void print(long l) {
545
         write(String.valueOf(l));
546
     }

    
Prints a floating-point number. The string produced by 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 write(int) method.

Parameters:
f The float to be printed
See also:
java.lang.Float.toString(float)
557
 
558
     public void print(float f) {
559
         write(String.valueOf(f));
560
     }

    
Prints a double-precision floating-point number. The string produced by 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 write(int) method.

Parameters:
d The double to be printed
See also:
java.lang.Double.toString(double)
571
 
572
     public void print(double d) {
573
         write(String.valueOf(d));
574
     }

    
Prints 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 write(int) method.

Parameters:
s The array of chars to be printed
Throws:
java.lang.NullPointerException If s is null
585
 
586
     public void print(char s[]) {
587
         write(s);
588
     }

    
Prints 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 write(int) method.

Parameters:
s The String to be printed
598
 
599
     public void print(String s) {
600
         if (s == null) {
601
             s = "null";
602
         }
603
         write(s);
604
     }

    
Prints an object. The string produced by the java.lang.String.valueOf(java.lang.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 write(int) method.

Parameters:
obj The Object to be printed
See also:
java.lang.Object.toString()
615
 
616
     public void print(Object obj) {
617
         write(String.valueOf(obj));
618
     }
619
 
620
     /* Methods that do terminate lines */

    
Terminates 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'). 
627
 
628
     public void println() {
629
         newLine();
630
     }

    
Prints a boolean value and then terminates the line. This method behaves as though it invokes print(boolean) and then println().

Parameters:
x the boolean value to be printed
638
 
639
     public void println(boolean x) {
640
         synchronized () {
641
             print(x);
642
             println();
643
         }
644
     }

    
Prints a character and then terminates the line. This method behaves as though it invokes print(char) and then println().

Parameters:
x the char value to be printed
652
 
653
     public void println(char x) {
654
         synchronized () {
655
             print(x);
656
             println();
657
         }
658
     }

    
Prints an integer and then terminates the line. This method behaves as though it invokes print(int) and then println().

Parameters:
x the int value to be printed
666
 
667
     public void println(int x) {
668
         synchronized () {
669
             print(x);
670
             println();
671
         }
672
     }

    
Prints a long integer and then terminates the line. This method behaves as though it invokes print(long) and then println().

Parameters:
x the long value to be printed
680
 
681
     public void println(long x) {
682
         synchronized () {
683
             print(x);
684
             println();
685
         }
686
     }

    
Prints a floating-point number and then terminates the line. This method behaves as though it invokes print(float) and then println().

Parameters:
x the float value to be printed
694
 
695
     public void println(float x) {
696
         synchronized () {
697
             print(x);
698
             println();
699
         }
700
     }

    
Prints a double-precision floating-point number and then terminates the line. This method behaves as though it invokes print(double) and then println().

Parameters:
x the double value to be printed
708
 
709
     public void println(double x) {
710
         synchronized () {
711
             print(x);
712
             println();
713
         }
714
     }

    
Prints an array of characters and then terminates the line. This method behaves as though it invokes print(char[]) and then println().

Parameters:
x the array of char values to be printed
722
 
723
     public void println(char x[]) {
724
         synchronized () {
725
             print(x);
726
             println();
727
         }
728
     }

    
Prints a String and then terminates the line. This method behaves as though it invokes print(java.lang.String) and then println().

Parameters:
x the String value to be printed
736
 
737
     public void println(String x) {
738
         synchronized () {
739
             print(x);
740
             println();
741
         }
742
     }

    
Prints an Object and then terminates the line. This method calls at first String.valueOf(x) to get the printed object's string value, then behaves as though it invokes print(java.lang.String) and then println().

Parameters:
x The Object to be printed.
752
 
753
     public void println(Object x) {
754
         String s = String.valueOf(x);
755
         synchronized () {
756
             print(s);
757
             println();
758
         }
759
     }

    
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)

Parameters:
format A format string as described in Format string syntax.
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.
Returns:
This writer
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.
java.lang.NullPointerException If the format is null
Since:
1.5
802
 
803
     public PrintWriter printf(String format, Object ... args) {
804
         return format(format, args);
805
     }

    
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)

Parameters:
l The locale to apply during formatting. If l is null then no localization is applied.
format A format string as described in Format string syntax.
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.
Returns:
This writer
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.
java.lang.NullPointerException If the format is null
Since:
1.5
853
 
854
     public PrintWriter printf(Locale l, String format, Object ... args) {
855
         return format(l, format, args);
856
     }

    
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 java.util.Locale.getDefault(), regardless of any previous invocations of other formatting methods on this object.

Parameters:
format A format string as described in Format string syntax.
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.
Returns:
This writer
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.
java.lang.NullPointerException If the format is null
Since:
1.5
897
 
898
     public PrintWriter format(String format, Object ... args) {
899
         try {
900
             synchronized () {
901
                 ensureOpen();
902
                 if (( == null)
903
                     || (.locale() != Locale.getDefault()))
904
                      = new Formatter(this);
905
                 .format(Locale.getDefault(), format, args);
906
                 if ()
907
                     .flush();
908
             }
909
         } catch (InterruptedIOException x) {
910
             Thread.currentThread().interrupt();
911
         } catch (IOException x) {
912
              = true;
913
         }
914
         return this;
915
     }

    
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.

Parameters:
l The locale to apply during formatting. If l is null then no localization is applied.
format A format string as described in Format string syntax.
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.
Returns:
This writer
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.
java.lang.NullPointerException If the format is null
Since:
1.5
957
 
958
     public PrintWriter format(Locale l, String format, Object ... args) {
959
         try {
960
             synchronized () {
961
                 ensureOpen();
962
                 if (( == null) || (.locale() != l))
963
                      = new Formatter(this, l);
964
                 .format(l, format, args);
965
                 if ()
966
                     .flush();
967
             }
968
         } catch (InterruptedIOException x) {
969
             Thread.currentThread().interrupt();
970
         } catch (IOException x) {
971
              = true;
972
         }
973
         return this;
974
     }

    
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.

Parameters:
csq The character sequence to append. If csq is null, then the four characters "null" are appended to this writer.
Returns:
This writer
Since:
1.5
999
 
1000
    public PrintWriter append(CharSequence csq) {
1001
        if (csq == null)
1002
            write("null");
1003
        else
1004
            write(csq.toString());
1005
        return this;
1006
    }

    
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())

Parameters:
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".
start The index of the first character in the subsequence
end The index of the character following the last character in the subsequence
Returns:
This writer
Throws:
java.lang.IndexOutOfBoundsException If start or end are negative, start is greater than end, or end is greater than csq.length()
Since:
1.5
1040
    public PrintWriter append(CharSequence csq, int start, int end) {
1041
        CharSequence cs = (csq == null ? "null" : csq);
1042
        write(cs.subSequence(start, end).toString());
1043
        return this;
1044
    }

    
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)

Parameters:
c The 16-bit character to append
Returns:
This writer
Since:
1.5
1062
    public PrintWriter append(char c) {
1063
        write(c);
1064
        return this;
1065
    }
New to GrepCode? Check out our FAQ X