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

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Log4j redirect stdout to DailyRollingFileAppender
I have a java app that uses log4j. Config: log4j.rootLogger=info, file log4j.appender.file=org.apache.log4j.DailyRollingFileAppender log4j.appender.file.File=${user.home}/logs/app.log log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=%d [%t] %c %p %m%n So all the log statements are correctly appended to the file, but i am losing stdout ...
2. When/why to call System.out.flush() in Java
Why do certain streams need to be flushed (FileOutputStream and streams from Sockets) while the standard output stream does not? Every time someone uses the System.out PrintStream object, be it while calling println() or write(), they never flush the stream. However, other programmers habitually call flush() a PrintStream/PrintWriter with other streams. I've recently asked this question to s...
3. Java Charset problem on linux
problem: I have a string containing special characters which i convert to bytes and vice versa..the conversion works properly on windows but on linux the special character is not converted properly.the default charset on linux is UTF-8 as seen with Charset.defaultCharset.getdisplayName() however if i run on linux with option -Dfile.encoding=ISO-8859-1 it works properly.. how to make it work ...
4. Most idiomatic way to print a time difference in Java?
I'm familiar with printing time difference in milliseconds: long time = System.currentTimeMillis(); //do something that takes some time... long completedIn = System.currentTimeMillis() - time; But, is there a nice way print a complete time in a specified format (eg: HH:MM:SS) either using Apache Commons or even the dreaded platform API's Date/Time objects? In other words, what is the shor...
5. 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?
6. From compilation to runtime, how does Java String encoding really work
I recently realized that I don't fully understand Java's string encoding process. Consider the following code: public class Main { public static void main(String[] args) { System.out.println(java.nio.charset.Charset.defaultCharset().name()); System.out.println("ack char: ^"); /* where ^ = 0x06, the ack char */ } } Since the control characters are interpreted diff...
7. Unboxing or toString() is used in sysout in java
We know that when we use objects in sysout(System.out.Println) statement internally it's toString method is called. and with primitive it directly prints. but when we use any Wrapper class type of objects is used say suppose Integer like following Integer i = new Integer(10) System.out.Println(i); is it toString() is responsible for printing it or Unboxing?
8. Unicode Supplementary Multilingual Plane in Java
I want to work with SMP(Supplementary Multilingual Plane) in Java. Actually, I want to print a character whose codepoint is more than 0xFFFF. I used this line of code: int hexCodePoint = Character.toCodePoint('\uD801', '\uDC02' ); to have the codepoint of a special character. But how can I print this unicode character to the console? Thank you in advance for your help.
9. Method that accepts variable number of arguments?
For example, Java's own String.format() supports a variable number of arguments. String.format("Hello %s! ABC %d!", "World", 123); //=> Hello World! ABC 123! How can I make my own function that accepts a variable number of arguments? Follow-up question: I'm really trying to make a convenience shortcut for this: System.out.println( String.format("...", a, b, c) ); So that I can call...
10. How to add a UTF-8 BOM in java
I have a Java stored procedure which fetches record from the table using Resultset object and creates a csv file. BLOB retBLOB = BLOB.createTemporary(conn, true, BLOB.DURATION_SESSION); retBLOB.open(BLOB.MODE_READWRITE); OutputStream bOut = retBLOB.setBinaryStream(0L); ZipOutputStream zipOut = new ZipOutputStream(bOut); PrintStream out = new PrintStream(zipOut,false,"UTF-8"); out.write('\ufeff...
11. Difference between system.out.printf and String.format
may i know what is the difference between the two in java? i am reading a book and it can either use both of it to display strings.
12. What classes do you use to make string templates?
What classes do you use to make string placeholders work? String template = "You have %1 tickets for %d", Brr object = new Brr(template, {new Integer(1), new Date()}); object.print();
13. Confusion in print method in Java
Whenever I try to print the char arrays to the console, I'm getting the result in integer format, but whenever I try to print integer arrays to the console, I'm getting the result in hashcode format. Could anyone please tell me why? char[] arr={'4','5','6'}; System.out.println(arr); //456 int[] arr={4,5,6}; System.out.println(arr) //[I@3e25a5]
14. Strange behavior of Java String
I came across this program and its not behaving in expected way. public class StringTest { public static void main(String[] args) { String s = "Hello world"; for(int i = 0 ; i < s.length() ; i++) { System.out.write(s.charAt(i)); } } } If we think it should print Hello world but it prints nothing. What is going...
15. IOException inside print or println
Most of the IO operation requires try catch block or throws . Why is try catch or throws not required for System.out.print or println. If there is any exception inside these methods how would i know whats the exception and how to catch it.
16. If user passes a primitive type argument to println(), what exactly happens behind the scene?
If user passes a primitive type argument to println(), what exactly happens behind the scene? e.g. int i =1; System.out.println("My Int"+i); //and in System.out.println(i) How does it print "My Int 1" and "1", even though it needs a String object? updated.. What I think is AutoBoxing comes into play. Is that true, too?
17. Println(String s) vs println(Object o)
It seems to me that PrintStream.print(Object x) and PrintStream.println(Object x) are identical to PrintStream.print(String x) and PrintStream.println(String x). Is there any obvious reason for having both? Are they different in any way? API-docs-readability? Efficiency? (With autoboxing, I suspect that even the print-methods taking primitives as arguments are redundant... however these metho...
18. How to format string in Java
Primitive question.. But how do I format string like this: "Step {1} of {2}" by substituting variables using Java? In C# it's easy.
19. Is there a good reason to use "printf" instead of "print" in java?
I haven't had the chance to take any serious low-level programming courses in school. (I know I really should get going on learning the "behind-the-scenes" to be a better programmer.) I appreciate the conveniences of Java, including the ability to stick anything into a System.out.print statement. However, is there any reason why you would want to use System.out.printf instead? Also, should I ...
20. Java Class with string and a specified length
I'm creating a java program that creates a file and fills it with data in string form with each field in the record limited to a specific length. What I think I need to do is to create a class that has a string for the data field and a length specifying the length of the string. And then somehow restrict it so that the string never exceeds this length, either by bailing, padding with whitespac...
21. Java decimal precision question
I have a problem which I have to print with long decimal places. such as 1/3 = 0.33333333333333333333333333333333333333 (very very long) when using C, we can use printf("%.30f", a); but I don't know what to do using Java 
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;


A PrintStream adds functionality to another output stream, namely the ability to print representations of various data values conveniently. Two other features are provided as well. Unlike other output streams, a PrintStream never throws an IOException; instead, exceptional situations merely set an internal flag that can be tested via the checkError method. Optionally, a PrintStream can be created so as to flush automatically; this means that the flush method is automatically invoked after a byte array is written, one of the println methods is invoked, or a newline character or byte ('\n') is written.

All characters printed by a PrintStream are converted into bytes using the platform's default character encoding. The PrintWriter class should be used in situations that require writing characters rather than bytes.

Author(s):
Frank Yellin
Mark Reinhold
Since:
JDK1.0
53
  
54
  
55
  public class PrintStream extends FilterOutputStream
56
      implements Appendable, Closeable
57
  {
58
  
59
      private boolean autoFlush = false;
60
      private boolean trouble = false;
61
      private Formatter formatter;

    
Track both the text- and character-output streams, so that their buffers can be flushed without flushing the entire stream. 
66
  
67
      private BufferedWriter textOut;
68
      private OutputStreamWriter charOut;

    
Creates a new print stream. This stream will not flush automatically.

Parameters:
out The output stream to which values and objects will be printed
See also:
java.io.PrintWriter.PrintWriter.(java.io.OutputStream)
77
  
78
      public PrintStream(OutputStream out) {
79
          this(out, false);
80
      }
81
  
82
      /* Initialization is factored into a private constructor (note the swapped
83
       * parameters so that this one isn't confused with the public one) and a
84
       * separate init method so that the following two public constructors can
85
       * share code.  We use a separate init method so that the constructor that
86
       * takes an encoding will throw an NPE for a null stream before it throws
87
       * an UnsupportedEncodingException for an unsupported encoding.
88
       */
89
  
90
      private PrintStream(boolean autoFlush, OutputStream out)
91
      {
92
          super(out);
93
          if (out == null)
94
              throw new NullPointerException("Null output stream");
95
          this. = autoFlush;
96
      }
97
  
98
      private void init(OutputStreamWriter osw) {
99
          this. = osw;
100
         this. = new BufferedWriter(osw);
101
     }

    
Creates a new print stream.

Parameters:
out The output stream to which values and objects will be printed
autoFlush A boolean; if true, the output buffer will be flushed whenever a byte array is written, one of the println methods is invoked, or a newline character or byte ('\n') is written
See also:
java.io.PrintWriter.PrintWriter.(java.io.OutputStream,boolean)
114
 
115
     public PrintStream(OutputStream out, boolean autoFlush) {
116
         this(autoFlush, out);
117
         init(new OutputStreamWriter(this));
118
     }

    
Creates a new print stream.

Parameters:
out The output stream to which values and objects will be printed
autoFlush A boolean; if true, the output buffer will be flushed whenever a byte array is written, one of the println methods is invoked, or a newline character or byte ('\n') is written
encoding The name of a supported character encoding
Throws:
UnsupportedEncodingException If the named encoding is not supported
Since:
1.4
137
 
138
     public PrintStream(OutputStream out, boolean autoFlush, String encoding)
139
         throws UnsupportedEncodingException
140
     {
141
         this(autoFlush, out);
142
         init(new OutputStreamWriter(this, encoding));
143
     }

    
Creates a new print stream, without automatic line flushing, with the specified file name. This convenience constructor creates the necessary intermediate OutputStreamWriter, which will encode characters using the default charset for this instance of the Java virtual machine.

Parameters:
fileName The name of the file to use as the destination of this print stream. 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
171
 
172
     public PrintStream(String fileName) throws FileNotFoundException {
173
         this(false, new FileOutputStream(fileName));
174
         init(new OutputStreamWriter(this));
175
     }

    
Creates a new print stream, 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 print stream. 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
209
 
210
     public PrintStream(String fileName, String csn)
212
     {
213
         this(false, new FileOutputStream(fileName));
214
         init(new OutputStreamWriter(this, csn));
215
     }

    
Creates a new print stream, 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 print stream. 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
243
 
244
     public PrintStream(File file) throws FileNotFoundException {
245
         this(false, new FileOutputStream(file));
246
         init(new OutputStreamWriter(this));
247
     }

    
Creates a new print stream, 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 print stream. 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 presentand java.lang.SecurityManager.checkWrite(java.io.FileDescriptor) denies write access to the file
UnsupportedEncodingException If the named charset is not supported
Since:
1.5
281
 
282
     public PrintStream(File file, String csn)
284
     {
285
         this(false, new FileOutputStream(file));
286
         init(new OutputStreamWriter(this, csn));
287
     }

    
Check to make sure that the stream has not been closed
289
 
290
     private void ensureOpen() throws IOException {
291
         if ( == null)
292
             throw new IOException("Stream closed");
293
     }

    
Flushes the stream. This is done by writing any buffered output bytes to the underlying output stream and then flushing that stream.

See also:
OutputStream.flush()
300
 
301
     public void flush() {
302
         synchronized (this) {
303
             try {
304
                 ensureOpen();
305
                 .flush();
306
             }
307
             catch (IOException x) {
308
                  = true;
309
             }
310
         }
311
     }
312
 
313
     private boolean closing = false; /* To avoid recursive closing */

    
Closes the stream. This is done by flushing the stream and then closing the underlying output stream.

See also:
OutputStream.close()
320
 
321
     public void close() {
322
         synchronized (this) {
323
             if (! ) {
324
                  = true;
325
                 try {
326
                     .close();
327
                     .close();
328
                 }
329
                 catch (IOException x) {
330
                      = true;
331
                 }
332
                  = null;
333
                  = null;
334
                  = null;
335
             }
336
         }
337
     }

    
Flushes the stream and checks its error state. The internal error state is set to true when the underlying output stream throws an IOException other than InterruptedIOException, and when the setError method is invoked. If an operation on the underlying output stream throws an InterruptedIOException, then the PrintStream converts the exception back into an interrupt by doing: 
     Thread.currentThread().interrupt();
or the equivalent.

Returns:
true if and only if this stream has encountered an IOException other than InterruptedIOException, or the setError method has been invoked
356
 
357
     public boolean checkError() {
358
         if ( != null)
359
             flush();
360
         if ( instanceof java.io.PrintStream) {
361
             PrintStream ps = (PrintStream) ;
362
             return ps.checkError();
363
         }
364
         return ;
365
     }

    
Sets the error state of the stream to true.

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

Since:
JDK1.1
375
 
376
     protected void setError() {
377
          = true;
378
     }

    
Clears the internal 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
388
 
389
     protected void clearError() {
390
          = false;
391
     }
392
 
393
     /*
394
      * Exception-catching, synchronized output operations,
395
      * which also implement the write() methods of OutputStream
396
      */

    
Writes the specified byte to this stream. If the byte is a newline and automatic flushing is enabled then the flush method will be invoked.

Note that the byte is written as given; to write a character that will be translated according to the platform's default character encoding, use the print(char) or println(char) methods.

Parameters:
b The byte to be written
See also:
print(char)
println(char)
411
 
412
     public void write(int b) {
413
         try {
414
             synchronized (this) {
415
                 ensureOpen();
416
                 .write(b);
417
                 if ((b == '\n') && )
418
                     .flush();
419
             }
420
         }
421
         catch (InterruptedIOException x) {
422
             Thread.currentThread().interrupt();
423
         }
424
         catch (IOException x) {
425
              = true;
426
         }
427
     }

    
Writes len bytes from the specified byte array starting at offset off to this stream. If automatic flushing is enabled then the flush method will be invoked.

Note that the bytes will be written as given; to write characters that will be translated according to the platform's default character encoding, use the print(char) or println(char) methods.

Parameters:
buf A byte array
off Offset from which to start taking bytes
len Number of bytes to write
442
 
443
     public void write(byte buf[], int off, int len) {
444
         try {
445
             synchronized (this) {
446
                 ensureOpen();
447
                 .write(buf, off, len);
448
                 if ()
449
                     .flush();
450
             }
451
         }
452
         catch (InterruptedIOException x) {
453
             Thread.currentThread().interrupt();
454
         }
455
         catch (IOException x) {
456
              = true;
457
         }
458
     }
459
 
460
     /*
461
      * The following private methods on the text- and character-output streams
462
      * always flush the stream buffers, so that writes to the underlying byte
463
      * stream occur as promptly as with the original PrintStream.
464
      */
465
 
466
     private void write(char buf[]) {
467
         try {
468
             synchronized (this) {
469
                 ensureOpen();
470
                 .write(buf);
471
                 .flushBuffer();
472
                 .flushBuffer();
473
                 if () {
474
                     for (int i = 0; i < buf.length; i++)
475
                         if (buf[i] == '\n')
476
                             .flush();
477
                 }
478
             }
479
         }
480
         catch (InterruptedIOException x) {
481
             Thread.currentThread().interrupt();
482
         }
483
         catch (IOException x) {
484
              = true;
485
         }
486
     }
487
 
488
     private void write(String s) {
489
         try {
490
             synchronized (this) {
491
                 ensureOpen();
492
                 .write(s);
493
                 .flushBuffer();
494
                 .flushBuffer();
495
                 if ( && (s.indexOf('\n') >= 0))
496
                     .flush();
497
             }
498
         }
499
         catch (InterruptedIOException x) {
500
             Thread.currentThread().interrupt();
501
         }
502
         catch (IOException x) {
503
              = true;
504
         }
505
     }
506
 
507
     private void newLine() {
508
         try {
509
             synchronized (this) {
510
                 ensureOpen();
511
                 .newLine();
512
                 .flushBuffer();
513
                 .flushBuffer();
514
                 if ()
515
                     .flush();
516
             }
517
         }
518
         catch (InterruptedIOException x) {
519
             Thread.currentThread().interrupt();
520
         }
521
         catch (IOException x) {
522
              = true;
523
         }
524
     }
525
 
526
     /* 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
536
 
537
     public void print(boolean b) {
538
         write(b ? "true" : "false");
539
     }

    
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
548
 
549
     public void print(char c) {
550
         write(String.valueOf(c));
551
     }

    
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)
562
 
563
     public void print(int i) {
564
         write(String.valueOf(i));
565
     }

    
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)
576
 
577
     public void print(long l) {
578
         write(String.valueOf(l));
579
     }

    
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)
590
 
591
     public void print(float f) {
592
         write(String.valueOf(f));
593
     }

    
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)
604
 
605
     public void print(double d) {
606
         write(String.valueOf(d));
607
     }

    
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
618
 
619
     public void print(char s[]) {
620
         write(s);
621
     }

    
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
631
 
632
     public void print(String s) {
633
         if (s == null) {
634
             s = "null";
635
         }
636
         write(s);
637
     }

    
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()
648
 
649
     public void print(Object obj) {
650
         write(String.valueOf(obj));
651
     }
652
 
653
 
654
     /* 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'). 
661
 
662
     public void println() {
663
         newLine();
664
     }

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

Parameters:
x The boolean to be printed
672
 
673
     public void println(boolean x) {
674
         synchronized (this) {
675
             print(x);
676
             newLine();
677
         }
678
     }

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

Parameters:
x The char to be printed.
686
 
687
     public void println(char x) {
688
         synchronized (this) {
689
             print(x);
690
             newLine();
691
         }
692
     }

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

Parameters:
x The int to be printed.
700
 
701
     public void println(int x) {
702
         synchronized (this) {
703
             print(x);
704
             newLine();
705
         }
706
     }

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

Parameters:
x a The long to be printed.
714
 
715
     public void println(long x) {
716
         synchronized (this) {
717
             print(x);
718
             newLine();
719
         }
720
     }

    
Prints a float and then terminate the line. This method behaves as though it invokes print(float) and then println().

Parameters:
x The float to be printed.
728
 
729
     public void println(float x) {
730
         synchronized (this) {
731
             print(x);
732
             newLine();
733
         }
734
     }

    
Prints a double and then terminate the line. This method behaves as though it invokes print(double) and then println().

Parameters:
x The double to be printed.
742
 
743
     public void println(double x) {
744
         synchronized (this) {
745
             print(x);
746
             newLine();
747
         }
748
     }

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

Parameters:
x an array of chars to print.
756
 
757
     public void println(char x[]) {
758
         synchronized (this) {
759
             print(x);
760
             newLine();
761
         }
762
     }

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

Parameters:
x The String to be printed.
770
 
771
     public void println(String x) {
772
         synchronized (this) {
773
             print(x);
774
             newLine();
775
         }
776
     }

    
Prints an Object and then terminate 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.
786
 
787
     public void println(Object x) {
788
         String s = String.valueOf(x);
789
         synchronized (this) {
790
             print(s);
791
             newLine();
792
         }
793
     }


    
A convenience method to write a formatted string to this output stream using the specified format string and arguments.

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 output stream
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
836
 
837
     public PrintStream printf(String format, Object ... args) {
838
         return format(format, args);
839
     }

    
A convenience method to write a formatted string to this output stream using the specified format string and arguments.

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 output stream
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
886
 
887
     public PrintStream printf(Locale l, String format, Object ... args) {
888
         return format(l, format, args);
889
     }

    
Writes a formatted string to this output stream using the specified format string and arguments.

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

    
Writes a formatted string to this output stream using the specified format string and arguments.

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 output stream
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
986
 
987
     public PrintStream format(Locale l, String format, Object ... args) {
988
         try {
989
             synchronized (this) {
990
                 ensureOpen();
991
                 if (( == null)
992
                     || (.locale() != l))
993
                      = new Formatter(this, l);
994
                 .format(l, format, args);
995
             }
996
         } catch (InterruptedIOException x) {
997
             Thread.currentThread().interrupt();
998
         } catch (IOException x) {
999
              = true;
1000
        }
1001
        return this;
1002
    }

    
Appends the specified character sequence to this output stream.

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

     out.print(csq.toString())

Depending on the specification of toString for the character sequence csq, the entire sequence may not be appended. For instance, invoking then 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 output stream.
Returns:
This output stream
Since:
1.5
1028
    public PrintStream append(CharSequence csq) {
1029
        if (csq == null)
1030
            print("null");
1031
        else
1032
            print(csq.toString());
1033
        return this;
1034
    }

    
Appends a subsequence of the specified character sequence to this output stream.

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.print(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 output stream
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
1069
    public PrintStream append(CharSequence csq, int start, int end) {
1070
        CharSequence cs = (csq == null ? "null" : csq);
1071
        write(cs.subSequence(start, end).toString());
1072
        return this;
1073
    }

    
Appends the specified character to this output stream.

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

     out.print(c)

Parameters:
c The 16-bit character to append
Returns:
This output stream
Since:
1.5
1091
    public PrintStream append(char c) {
1092
        print(c);
1093
        return this;
1094
    }
New to GrepCode? Check out our FAQ X