Socket communication in Java enables communication between two endpoints over a network. There are two main types of sockets: TCP sockets and UDP sockets. Let's explain both types with examples: TCP Socket Communication: 1. **Server Side**: - The server creates a `ServerSocket` object to listen for incoming connections on a specific port. - When a client connects, the server accepts the connection and creates a `Socket` object to communicate with the client. - The server reads from and writes to the socket's input and output streams to communicate with the client. import java.io.*; import java.net.*; public class TCPServer { public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(12345); System.out.println("Server started. Waiting for client..."); Socket clientSocket = serverSocket.accept(); ...
Java Byte Streams
Byte streams in Java are used to handle input and output of raw binary data. They are suitable for handling low-level data such as images, audio, and binary files. Let's dive into an example to illustrate how byte streams work:
Example: Copying a File Using Byte Streams
In this example, we'll create a program that reads the contents of a source file and writes them into a destination file using byte streams.
import java.io.*;
public class ByteStreamExample {
public static void main(String[] args) {
String sourceFile = "source.txt";
String destinationFile = "destination.txt";
try (FileInputStream fis = new FileInputStream(sourceFile);
FileOutputStream fos = new FileOutputStream(destinationFile)) {
int byteRead;
while ((byteRead = fis.read()) != -1) {
fos.write(byteRead);
}
System.out.println("File copied successfully!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Explanation:
- We import the necessary classes from the `java.io` package for file input and output operations.
- Inside the `main` method, we specify the source and destination file names.
- We create a `FileInputStream` to read bytes from the source file and a `FileOutputStream` to write bytes to the destination file. We use try-with-resources to ensure proper resource management, which automatically closes the streams after use.
- We use a `while` loop to read bytes from the source file (`fis.read()`) and write them to the destination file (`fos.write()`). The loop continues until the `read` method returns `-1`, indicating the end of the file.
- If any `IOException` occurs during file operations, we catch and print the exception stack trace.
Execution:
1. Ensure that the source file (`source.txt`) exists and contains some text.
2. Run the `ByteStreamExample` class.
3. Check the destination file (`destination.txt`) to verify that the contents have been copied successfully.
This example demonstrates the basic usage of byte streams for file copying. Byte streams are efficient for handling binary data, but they are not suitable for processing text-based data where character encoding matters. For text-based operations, character streams should be used instead.
Comments
Post a Comment