# Java System.out.println() Example

**Date:** 2019-09-09

Understanding Java's System.out.println(): A Deep Dive

Java, a powerful and widely used programming language, provides various mechanisms for interacting with the console, the primary interface for displaying information to a user.  One of the most fundamental of these is the `System.out.println()` statement, a cornerstone of many Java programs. This statement, deceptively simple in appearance, offers a gateway to understanding crucial concepts in input/output operations and program execution.

The core function of `System.out.println()` is to display text on the console.  It’s a command that instructs the Java Virtual Machine (JVM) to take the provided text—which can be a simple string, a number, or the result of a calculation—and send it to the standard output stream.  This standard output stream is typically the console window where you run your Java program. The "ln" suffix in `println()` is short for "newline," meaning after displaying the text, the cursor moves to the beginning of the next line. This ensures that subsequent output appears on a separate line.  Without the "ln," using just `print()`, the output would continue on the same line.

The statement itself is composed of three parts: `System`, `out`, and `println()`.  `System` is a pre-defined class in Java that provides access to system resources. `out` is a static member variable of the `System` class, representing the standard output stream.  Finally, `println()` is a method of the `PrintStream` class (to which `out` belongs) that performs the actual printing to the console.

Consider the differences between `println()` and `print()`.  If you used `System.out.print("Hello")` followed by `System.out.print(" World")`, the output would be "Hello World" all on the same line.  However, using `System.out.println("Hello")` followed by `System.out.println(" World")` would result in "Hello" on one line and "World" on the next, due to the automatic newline character added by `println()`.

It's important to distinguish `System.out` from other similar streams like `System.in` and `System.err`. `System.in` represents the standard input stream, allowing your program to receive data from the user through the console, while `System.err` is the standard error stream, typically used for displaying error messages and warnings.  These different streams provide structured ways of managing various types of information flowing into and out of your program.


The standard output stream, represented by `System.out`, can be customized.  This means that instead of sending the output to the console, you can redirect it to a file. This is particularly useful for logging purposes, where you might want to save the output of your program for later analysis.  This redirection involves manipulating the stream's destination, which could involve creating a new `PrintStream` object pointing to a file.  The original `System.out` could be saved before the redirection, allowing for reversion back to the console output later in the program.

In a production environment, however, the extensive use of `System.out.println()` is generally discouraged.  The reasons for this are multiple: performance overhead, lack of control over output formatting, and difficulty in managing large volumes of log messages.  Directly using `System.out.println()` adds unnecessary overhead compared to logging frameworks such as Log4j, Log4j2, or SLF4j. These frameworks offer much more sophisticated features, including log levels (allowing you to filter different types of messages), customized output formats, and the ability to send log messages to multiple destinations (console, files, databases, remote servers). This detailed control is essential for debugging and monitoring in large-scale applications.

Furthermore, the frequent inclusion of `System.out.println()` statements in a code base can lead to a cluttered and less readable code style.  In an effort to make the code more concise and readable, developers often employ static imports, importing `println()` directly, therefore removing the need to write `System.out.`  However, even with static imports, overuse of `println()` still undermines the benefits of professional logging frameworks.

The performance implications of `System.out.println()` are often overlooked. Behind the scenes, several method calls are involved in displaying a single line of text: `println()` delegates to `print()`, which further utilizes `write()` combined with `newLine()`. Both `write()` and `newLine()` often include synchronization mechanisms to ensure thread safety, which adds a small amount of overhead to the printing process.  While this overhead is often insignificant for smaller programs, in larger, high-performance applications, it can accumulate and impact overall performance.

In summary, `System.out.println()` is a foundational tool for basic output in Java.  Its simplicity makes it ideal for learning and testing, and in simple applications, its use is perfectly acceptable.  However, for more complex projects, especially those requiring robust logging and performance optimization, dedicated logging frameworks offer far superior capabilities, providing better control, scalability, and readability.  Understanding the intricacies of `System.out.println()` lays a solid groundwork for appreciating the capabilities and necessity of more advanced logging solutions.


**[Read more](https://examples.javacodegeeks.com/java-system-out-println-example/)**