Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Java: Difference between PrintStream and PrintWriter
What is the difference between PrintStream and PrintWriter? They have much methods in common. I always mix up this classes because of that reason. And I think we can use them for exactly the same. But there has to be a difference. Otherwise there was only one class. I first searched on StackOverflow, but not yet this question.
2. Difference between java.io.PrintWriter and java.io.BufferedWriter?
Please look through the below code, // A.java File file=new File("blah.txt"); FileWriter fwriter=new FileWriter(file); PrintWriter pwriter=new PrintWriter(fwriter); //B.java File file=new File("blah.txt"); FileWriter fwriter=new FileWriter(file); BufferedWriter bwriter=new BufferedWriter(bwriter); What is the difference between these two files? And when do we need to go for PrintWriter and ...
3. Which Class used for writing characters rather than bytes?
Which class should be used in situations that require writing characters rather than bytes?
4. Problem in TCP Program (Java)
Can anyone help me debug this program? The following is server code : package networking; import java.io.IOException; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; import java.util.Scanner; class TcpServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(5555); while (true) { ...
5. Java + Eclipse: Synchronize stdout and stderr
I use Eclipse. When I have an application like this: write 20 times 'Hello World\n' to stdout write 'ERROR\n' to stderr write 5 times 'Hello World\n' to stdout The output looks many times like this: Hello World Hello World Hello World Hello World Hello World Hello World ... Hello World Hello World Hello World ERROR Is there a way to synchronize these two output streams? Of course without...
6. PrintWriter and PrintStream never throw IOExceptions
Some days ago I realized that PrintWriter (as well as PrintStream) never throw an IOException when writing, flushing or closing. Instead it sets an internal flag (trouble=true) when an error occurs. It's not possible to get the exact exception, but only if there was some exception (checkError()). My question is: why would one want to have such behavior? Isn't that bad API design?
7. Why does a local PrintWriter interfere with another local PrintWriter?
In this program, the third string never gets printed. Why? (This Java program was run on Eclipse Indigo on Ubuntu 10.10.) import java.io.PrintWriter; public class Tester { static void nested() { PrintWriter object2 = new PrintWriter(System.out, true); object2.println("second"); object2.close(); // delete this line to make all strings print } public...
8. How to store printStackTrace into a string
How can I get the e.printStackTrace() and store it into a String variable? I want to use the string generated by e.printStackTrace() later in my program. I'm still new to Java so I'm not too familiar with StringWriter that I think will be the solution. Or if you have any other ideas please let me know. Thanks
9. Simple stream read/write question in java
I'm trying to upload a file via URLConnection, but I need to read/write it as a binary file without any encoding changes. So i've tried to read byte[] array from a FileInputStream, but now i have an issue. The PrintWriter object I use for outputing to the server does not allow me to do writer.write(content) (where content is of type byte[]). How can i fix this? Or is there another way to quick...
10. Creating UTF-8 files in Java from a runnable Jar
I have a little Java project where I've set the properties of the class files to UTF-8 (I use a lot of foreign characters not found on the default CP1252). The goal is to create a text file (in Windows) containing a list of items. When running the class files from Eclipse itself (hitting Ctrl+F11) it creates the file flawlessly and opening it in another editor (I'm using Notepad++) I can see t...
11. Is there an easy way to concatenate several lines of text into a string without constantly appending a newline?
So I essentially need to do this: String text = "line1\n"; text += "line2\n"; text += "line3\n"; useString( text ); There is more involved, but that's the basic idea. Is there anything out there that might let me do something more along the lines of this though? DesiredStringThinger text = new DesiredStringThinger(); text.append( "line1" ); text.append( "line2" ); text.append( "line3" ); us...
12. ISO 8859-1 Encoding of files printed in Java program
I write a program that implements a file structure, the program prints out a product file based on the structure. Product names include letters Æ, Ø and Å. These letters are not displayed correctly in the output file. I use PrintWriter printer = new PrintWriter(new FileOutputStream(new File("products.txt"))); IS0 8859 - 1 or Windows ANSI (CP 1252) is the character sets that the implementati...
13. Write string to output stream
I have several output listeners implementing OutputStream. It can be PrintStream writing to stdout or to a File, it can be writing to memory or any other output destination therefore I specified OutputStream as argument in the method. I have receiving the String. What is best way to write to streams here? Just to use Writer.write(message.getBytes())? I give bytes but if destination stream is ...
14. How to write a hashtable in to text file,java?
I have hastable htmlcontent is html string of urlstring . I want to write hastable into a .text file . Can you suget me a sulution ?
15. PrintWriter in java giving unexpected behaviour
import java.io.*; class demo { public static void main(String args[]) { PrintWriter pw=new PrintWriter(System.out); pw.println("java"); //pw.print("java"); } } // the output is java using pw.println but output is null using pw.print i.e nothing gets printed on console while using print.
16. Update text file with BufferedWriter
I am writing to a text file using a BufferedWriter but the BufferedWriter does not write to the file until the program I'm running is finished and I'm not sure how to update it as the BufferedWriter is supposedly writing. Here is some of my code that I have: FileWriter fw = null; try { fw = new FileWriter("C:/.../" + target + ".pscr",true); writer = new BufferedWriter(fw); writer....
17. Determining and printing file size in Java
The method below returns file size as 2. Since it is long, I'm assuming the file size java calculates is 2*64 bits. But actually I saved a 32 bit int + a 16 bit char = 48 bits. Why does Java do this conversion? Also, does Java implicitly store everything as long in the file no matter if char or int ? How do I get the accurate size of 48 bits ? public static void main(String[] args) {...
18. How do I make eclipse print out weird characters in unicode?
So I'm trying to make my program output a text file with a list of names. Some of the names have weird characters, such as Åström. I have grabbed these list of names from a webpage that is encoded in "UTF-8", or at least I'm pretty sure it does because the page source says " meta http-equiv="Content-Type" content="text/html; charset=UTF-8" / " This is what I've tried so far: public sta...
19. How to redirect a Java ResponseWriter?
For debug reasons, I want to see the ouput of my ResponseWriter directly in standard output. Because the response will be processed by JavaScript I am not able to see the output there. Is there an easy solution to redirect the ResponseWriter to standard output?
20. Replace the first line of a file in android
Hello In my android application i would like to replace my first line of a txt file with some other data. Is there any way that i can do this. Please let me know your valuable suggestions. Thanks in advance :)
21. Storing names and other information
I am creating a prison system where I need to store the names and because I need to print out all the prisoner information in one of the methods. I want to make it remember and store information such as name, id and crimes etc. How can I go about doing this? About the posted answers, I don't think it needs to be something that complicated because I haven't learnt any of this for the assignmen... 
1
   /*
2
    * Copyright 1996-2006 Sun Microsystems, Inc.  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.  Sun designates this
8
    * particular file as subject to the "Classpath" exception as provided
9
    * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
   * CA 95054 USA or visit www.sun.com if you need additional information or
23
   * have any questions.
24
   */
25
  
26
  package java.io;
27
  
29
  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
50
  
51
  
52
  public class PrintWriter extends Writer {

    
The underlying character-output stream of this PrintWriter.

Since:
1.2
59
  
60
      protected Writer out;
61
  
62
      private boolean autoFlush = false;
63
      private boolean trouble = false;
64
      private Formatter formatter;
65
      private PrintStream psOut = null;

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

    
Creates a new PrintWriter, without automatic line flushing.

Parameters:
out A character-output stream
77
  
78
      public PrintWriter (Writer out) {
79
          this(out, false);
80
      }

    
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
89
  
90
      public PrintWriter(Writer out,
91
                         boolean autoFlush) {
92
          super(out);
93
          this. = out;
94
          this. = autoFlush;
95
           = java.security.AccessController.doPrivileged(
96
              new sun.security.action.GetPropertyAction("line.separator"));
97
      }

    
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)
108
 
109
     public PrintWriter(OutputStream out) {
110
         this(out, false);
111
     }

    
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)
125
 
126
     public PrintWriter(OutputStream out, boolean autoFlush) {
127
         this(new BufferedWriter(new OutputStreamWriter(out)), autoFlush);
128
 
129
         // save print stream for error propagation
130
         if (out instanceof java.io.PrintStream) {
131
              = (PrintStream) out;
132
         }
133
     }

    
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
161
 
162
     public PrintWriter(String fileName) throws FileNotFoundException {
163
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName))),
164
              false);
165
     }

    
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
199
 
200
     public PrintWriter(String fileName, String csn)
202
     {
203
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName), csn)),
204
              false);
205
     }

    
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
233
 
234
     public PrintWriter(File file) throws FileNotFoundException {
235
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file))),
236
              false);
237
     }

    
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
271
 
272
     public PrintWriter(File file, String csn)
274
     {
275
         this(new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), csn)),
276
              false);
277
     }

    
Checks to make sure that the stream has not been closed
279
 
280
     private void ensureOpen() throws IOException {
281
         if ( == null)
282
             throw new IOException("Stream closed");
283
     }

    
Flushes the stream.

See also:
checkError()
288
 
289
     public void flush() {
290
         try {
291
             synchronized () {
292
                 ensureOpen();
293
                 .flush();
294
             }
295
         }
296
         catch (IOException x) {
297
              = true;
298
         }
299
     }

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

See also:
checkError()
306
 
307
     public void close() {
308
         try {
309
             synchronized () {
310
                 if ( == null)
311
                     return;
312
                 .close();
313
                  = null;
314
             }
315
         }
316
         catch (IOException x) {
317
              = true;
318
         }
319
     }

    
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.
327
 
328
     public boolean checkError() {
329
         if ( != null) {
330
             flush();
331
         }
332
         if ( instanceof java.io.PrintWriter) {
333
             PrintWriter pw = (PrintWriter) ;
334
             return pw.checkError();
335
         } else if ( != null) {
336
             return .checkError();
337
         }
338
         return ;
339
     }

    
Indicates that an error has occurred.

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

347
 
348
     protected void setError() {
349
          = true;
350
     }

    
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
360
 
361
     protected void clearError() {
362
          = false;
363
     }
364
 
365
     /*
366
      * Exception-catching, synchronized output operations,
367
      * which also implement the write() methods of Writer
368
      */

    
Writes a single character.

Parameters:
c int specifying a character to be written.
373
 
374
     public void write(int c) {
375
         try {
376
             synchronized () {
377
                 ensureOpen();
378
                 .write(c);
379
             }
380
         }
381
         catch (InterruptedIOException x) {
382
             Thread.currentThread().interrupt();
383
         }
384
         catch (IOException x) {
385
              = true;
386
         }
387
     }

    
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
394
 
395
     public void write(char buf[], int off, int len) {
396
         try {
397
             synchronized () {
398
                 ensureOpen();
399
                 .write(buf, off, len);
400
             }
401
         }
402
         catch (InterruptedIOException x) {
403
             Thread.currentThread().interrupt();
404
         }
405
         catch (IOException x) {
406
              = true;
407
         }
408
     }

    
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
414
 
415
     public void write(char buf[]) {
416
         write(buf, 0, buf.length);
417
     }

    
Writes a portion of a string.

Parameters:
s A String
off Offset from which to start writing characters
len Number of characters to write
424
 
425
     public void write(String s, int off, int len) {
426
         try {
427
             synchronized () {
428
                 ensureOpen();
429
                 .write(s, off, len);
430
             }
431
         }
432
         catch (InterruptedIOException x) {
433
             Thread.currentThread().interrupt();
434
         }
435
         catch (IOException x) {
436
              = true;
437
         }
438
     }

    
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
444
 
445
     public void write(String s) {
446
         write(s, 0, s.length());
447
     }
448
 
449
     private void newLine() {
450
         try {
451
             synchronized () {
452
                 ensureOpen();
453
                 .write();
454
                 if ()
455
                     .flush();
456
             }
457
         }
458
         catch (InterruptedIOException x) {
459
             Thread.currentThread().interrupt();
460
         }
461
         catch (IOException x) {
462
              = true;
463
         }
464
     }
465
 
466
     /* 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
476
 
477
     public void print(boolean b) {
478
         write(b ? "true" : "false");
479
     }

    
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
488
 
489
     public void print(char c) {
490
         write(c);
491
     }

    
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)
502
 
503
     public void print(int i) {
504
         write(String.valueOf(i));
505
     }

    
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)
516
 
517
     public void print(long l) {
518
         write(String.valueOf(l));
519
     }

    
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)
530
 
531
     public void print(float f) {
532
         write(String.valueOf(f));
533
     }

    
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)
544
 
545
     public void print(double d) {
546
         write(String.valueOf(d));
547
     }

    
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
558
 
559
     public void print(char s[]) {
560
         write(s);
561
     }

    
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
571
 
572
     public void print(String s) {
573
         if (s == null) {
574
             s = "null";
575
         }
576
         write(s);
577
     }

    
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()
588
 
589
     public void print(Object obj) {
590
         write(String.valueOf(obj));
591
     }
592
 
593
     /* 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'). 
600
 
601
     public void println() {
602
         newLine();
603
     }

    
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
611
 
612
     public void println(boolean x) {
613
         synchronized () {
614
             print(x);
615
             println();
616
         }
617
     }

    
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
625
 
626
     public void println(char x) {
627
         synchronized () {
628
             print(x);
629
             println();
630
         }
631
     }

    
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
639
 
640
     public void println(int x) {
641
         synchronized () {
642
             print(x);
643
             println();
644
         }
645
     }

    
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
653
 
654
     public void println(long x) {
655
         synchronized () {
656
             print(x);
657
             println();
658
         }
659
     }

    
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
667
 
668
     public void println(float x) {
669
         synchronized () {
670
             print(x);
671
             println();
672
         }
673
     }

    
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
681
 
682
     public void println(double x) {
683
         synchronized () {
684
             print(x);
685
             println();
686
         }
687
     }

    
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
695
 
696
     public void println(char x[]) {
697
         synchronized () {
698
             print(x);
699
             println();
700
         }
701
     }

    
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
709
 
710
     public void println(String x) {
711
         synchronized () {
712
             print(x);
713
             println();
714
         }
715
     }

    
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.
725
 
726
     public void println(Object x) {
727
         String s = String.valueOf(x);
728
         synchronized () {
729
             print(s);
730
             println();
731
         }
732
     }

    
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
775
 
776
     public PrintWriter printf(String format, Object ... args) {
777
         return format(format, args);
778
     }

    
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
826
 
827
     public PrintWriter printf(Locale l, String format, Object ... args) {
828
         return format(l, format, args);
829
     }

    
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
870
 
871
     public PrintWriter format(String format, Object ... args) {
872
         try {
873
             synchronized () {
874
                 ensureOpen();
875
                 if (( == null)
876
                     || (.locale() != Locale.getDefault()))
877
                      = new Formatter(this);
878
                 .format(Locale.getDefault(), format, args);
879
                 if ()
880
                     .flush();
881
             }
882
         } catch (InterruptedIOException x) {
883
             Thread.currentThread().interrupt();
884
         } catch (IOException x) {
885
              = true;
886
         }
887
         return this;
888
     }

    
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
930
 
931
     public PrintWriter format(Locale l, String format, Object ... args) {
932
         try {
933
             synchronized () {
934
                 ensureOpen();
935
                 if (( == null) || (.locale() != l))
936
                      = new Formatter(this, l);
937
                 .format(l, format, args);
938
                 if ()
939
                     .flush();
940
             }
941
         } catch (InterruptedIOException x) {
942
             Thread.currentThread().interrupt();
943
         } catch (IOException x) {
944
              = true;
945
         }
946
         return this;
947
     }

    
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
972
 
973
     public PrintWriter append(CharSequence csq) {
974
         if (csq == null)
975
             write("null");
976
         else
977
             write(csq.toString());
978
         return this;
979
     }

    
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
1013
    public PrintWriter append(CharSequence csq, int start, int end) {
1014
        CharSequence cs = (csq == null ? "null" : csq);
1015
        write(cs.subSequence(start, end).toString());
1016
        return this;
1017
    }

    
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
1035
    public PrintWriter append(char c) {
1036
        write(c);
1037
        return this;
1038
    }
New to GrepCode? Check out our FAQ X