1. Introduction to Java Input and Output
In this lesson of Java course, we will learn about the Java input and output. Java I/O, often simply referred to as “I/O,” refers to the process of transferring data between a program and external sources such as files, the console, or network connections. It is a critical aspect of Java programming as it allows programs to interact with the outside world. In Java, I/O is divided into several categories, including standard I/O (keyboard and console), file I/O (reading and writing files), byte and character streams, exception handling, working with directories, Java NIO (New I/O), network I/O, and serialization/de-serialization.
2. Standard Java Input and Output
2.1. Reading from Standard Input (Keyboard)
Java provides the Scanner class for reading input from the keyboard. Here’s an example of reading user input:
Reading Strings:
import java.util.Scanner;
public class KeyboardInputExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = scanner.nextLine();
System.out.println("Hello, " + name + "!");
}
}Reading Integers:
import java.util.Scanner;
public class InputExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter an integer: ");
int num = scanner.nextInt();
System.out.println("You entered: " + num);
scanner.close();
}
}Reading Floating-Point Numbers:
import java.util.Scanner;
public class InputExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a floating-point number: ");
double num = scanner.nextDouble();
System.out.println("You entered: " + num);
scanner.close();
}
}2.2. Writing to Standard Output (Console)
We can use the System.out object to write to the console. Here’s an example:
public class ConsoleOutputExample {
public static void main(String[] args) {
System.out.println("This is a message to the console.");
}
}print(): Theprint()method in Java is used to display text or data on the console or other output devices without moving the cursor to a new line. It simply prints the given data to the output stream. For example:
System.out.print("Hello, ");
System.out.print("world!");
// Output: Hello, world!println(): Theprintln()method is similar toprint(), but it also inserts a newline character after printing the data, which moves the cursor to the beginning of the next line. This is commonly used to format output neatly. For example:
System.out.println("Hello,");
System.out.println("world!");
// Output:
// Hello,
// world!printf(): The printf() method is used for formatted output in Java. It allows you to define a format string with placeholders and then provide values to be inserted into those placeholders. This is similar to the printf function in C and other languages.
In the format string,%sis a placeholder for a string,%dis a placeholder for an integer, and%nrepresents a newline character.
String name = "Alice";
int age = 30;
System.out.printf("Name: %s, Age: %d%n", name, age);
// Output: Name: Alice, Age: 303. File Input and Output
3.1. Reading from Files
Java provides various classes for reading from files, including FileInputStream, FileReader, and BufferedReader. Here’s an example of reading text from a file:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class FileReadExample {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}3.2. Writing to Files
Writing to files is achieved using classes like FileOutputStream, FileWriter, and BufferedWriter. Here’s an example of writing text to a file:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriteExample {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("Hello, World!");
} catch (IOException e) {
e.printStackTrace();
}
}
}4. Byte Streams and Character Streams
Java provides both byte and character streams for I/O operations.
4.1. Byte Streams
Byte streams are used for reading and writing binary data. Examples include FileInputStream and FileOutputStream.
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class ByteStreamExample {
public static void main(String[] args) {
try (FileInputStream in = new FileInputStream("input.bin");
FileOutputStream out = new FileOutputStream("output.bin")) {
int byteData;
while ((byteData = in.read()) != -1) {
out.write(byteData);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}4.2. Character Streams
Character streams are used for reading and writing text data. Examples include FileReader and FileWriter.
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class CharacterStreamExample {
public static void main(String[] args) {
try (FileReader reader = new FileReader("input.txt");
FileWriter writer = new FileWriter("output.txt")) {
int charData;
while ((charData = reader.read()) != -1) {
writer.write(charData);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}5. Working with Directories
Java provides classes like File to work with directories. We can create, delete, or list directories and files within them.
import java.io.File;
public class DirectoryExample {
public static void main(String[] args) {
File directory = new File("my_directory");
// Create a directory
boolean created = directory.mkdir();
if (created) {
System.out.println("Directory created successfully.");
}
// List files in the directory
String[] files = directory.list();
for (String file : files) {
System.out.println(file);
}
// Delete the directory
boolean deleted = directory.delete();
if (deleted) {
System.out.println("Directory deleted successfully.");
}
}
}6. Serialization and Deserialization
Java allows objects to be serialized (converted to byte streams) and deserialized (reconstructed from byte streams). This is useful for saving and restoring object states.
import java.io.*;
public class SerializationExample {
public static void main(String[] args) {
try {
// Serialization
FileOutputStream fileOut = new FileOutputStream("object.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
MyClass obj = new MyClass("Hello, Serialization!");
out.writeObject(obj);
out.close();
fileOut.close();
// Deserialization
FileInputStream fileIn = new FileInputStream("object.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
MyClass newObj = (MyClass) in.readObject();
in.close();
fileIn.close();
System.out.println("Deserialized: " + newObj.getMessage());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class MyClass implements Serializable {
private String message;
public MyClass(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
}7. Examples of Java Input and Output
7.1. Reading and Writing Text Files
Here’s an example that reads data from an input text file, modifies it, and writes the modified data to an output text file:
import java.io.*;
import java.util.Scanner;
public class FileReadWriteExample {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(new FileReader("input.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
// Modify the line if needed
writer.write(line);
writer.newLine(); // Add a newline character
}
} catch (IOException e) {
e.printStackTrace();
}
}
}7.2.Copy Files
Copying a file from one location to another is a common I/O task. Here’s an example that copies a file using byte streams:
import java.io.*;
public class FileCopyExample {
public static void main(String[] args) {
try (FileInputStream in = new FileInputStream("source.txt");
FileOutputStream out = new FileOutputStream("destination.txt")) {
int byteData;
while ((byteData = in.read()) != -1) {
out.write(byteData);
}
System.out.println("File copied successfully.");
} catch (IOException e) {
e.printStackTrace();
}
}
}8. Best Practices in Java I/O
- Always close I/O resources (streams, readers, writers) using
try-with-resourcesto ensure proper resource management. - Use appropriate exceptions and error handling for robust I/O code.
- Consider performance and memory usage when choosing between byte and character streams.
- For text-based I/O, use character streams (
ReaderandWriter) along with proper character encoding. - Avoid hardcoding file paths and use relative or user-independent paths where possible.
- When working with large files or streams, consider using Java NIO for improved performance.
9. Conclusion
Java Input and Output (I/O) is a versatile and essential aspect of Java programming. It allows us to interact with external resources, read and write files, handle network communication, and serialize objects. By mastering I/O techniques and following best practices, we can build robust and efficient Java applications that can handle various data sources and scenarios. As always the source code of the lesson is available on out GitHub repository.
