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(); System.out.println("Client connected."); BufferedReader in = new Bu
StringBuffer Class in Java
`StringBuffer` is a class in Java that represents a mutable sequence of characters. Unlike the `String` class, which is immutable, a `StringBuffer` allows for the modification of its content without creating a new object. This makes it more efficient for situations where frequent modifications to a sequence of characters are required.
Key Features:
1. Mutability:
- `StringBuffer` objects are mutable, meaning the content of a `StringBuffer` instance can be modified after its creation.
2. Synchronization:
- `StringBuffer` is synchronized, making it thread-safe. This ensures that multiple threads can safely access and modify a `StringBuffer` object without interference.
3. Performance Considerations:
- While `StringBuffer` provides mutability, it might have performance overhead due to synchronization. If thread safety is not required, the non-synchronized class `StringBuilder` should be considered for better performance.
Common Methods:
Here are some commonly used methods of the `StringBuffer` class:
1. Constructor:
- `StringBuffer()`
- Creates an empty `StringBuffer` with the default initial capacity (16 characters).
- StringBuffer buffer = new StringBuffer();
2. Appending Content:
- `append(String str)`
- Appends the specified string to the end of the `StringBuffer`.
buffer.append("Hello");
buffer.append(" World");
3. Inserting Content:
- `insert(int offset, String str)`
- Inserts the specified string at the specified offset.
- buffer.insert(5, " Java");
4. Deleting Content:
- `delete(int start, int end)`
- Deletes the characters between the specified `start` (inclusive) and `end` (exclusive) indices.
buffer.delete(6, 11);
5. Reversing Content:
- `reverse()`
- Reverses the characters in the `StringBuffer`.
- buffer.reverse();
6. Capacity Management:
- `capacity()`
- Returns the current capacity of the `StringBuffer`.
- int capacity = buffer.capacity();
- `ensureCapacity(int minCapacity)`
- Ensures that the capacity of the `StringBuffer` is at least equal to the specified minimum capacity.
- buffer.ensureCapacity(50);
7. Converting to String:
- `toString()`
- Converts the `StringBuffer` to a `String`.
- String result = buffer.toString();
Example Usage:
// Creating a StringBuffer
StringBuffer buffer = new StringBuffer();
// Appending content
buffer.append("Hello");
buffer.append(" World");
// Inserting content
buffer.insert(5, " Java");
// Deleting content
buffer.delete(6, 11);
// Reversing content
buffer.reverse();
// Converting to String
String result = buffer.toString();
The `StringBuffer` class provides a flexible and thread-safe way to work with mutable character sequences in Java. If synchronization is not required, consider using the `StringBuilder` class for potentially better performance.
Comments
Post a Comment