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
StringBuilder Class in Java
The `StringBuilder` class in Java represents a mutable sequence of characters. Similar to `StringBuffer`, `StringBuilder` allows for the modification of its content without creating a new object. However, unlike `StringBuffer`, `StringBuilder` is not synchronized, making it more efficient in situations where thread safety is not a concern.
Key Features:
1.Mutability:
- `StringBuilder` objects are mutable, allowing for the modification of content after creation.
2. Non-Synchronization:
- Unlike `StringBuffer`, `StringBuilder` is not synchronized. This lack of synchronization improves performance but means it is not thread-safe.
3. Performance Considerations:
- If thread safety is not a requirement, `StringBuilder` is generally preferred over `StringBuffer` due to its higher performance.
Common Methods:
Here are some commonly used methods of the `StringBuilder` class:
1. Constructor:
-`StringBuilder()`
- Creates an empty `StringBuilder` with the default initial capacity (16 characters).
- StringBuilder builder = new StringBuilder();
- `StringBuilder(int capacity)`
- Creates an empty `StringBuilder` with the specified initial capacity.
- StringBuilder builderWithCapacity = new StringBuilder(30);
2. Appending Content:
- `append(String str)`
- Appends the specified string to the end of the `StringBuilder`.
builder.append("Hello");
builder.append(" World");
3. Inserting Content:
- `insert(int offset, String str)`
- Inserts the specified string at the specified offset.
- builder.insert(5, " Java");
4. Deleting Content:
- `delete(int start, int end)`
- Deletes the characters between the specified `start` (inclusive) and `end` (exclusive) indices.
builder.delete(6, 11);
5. Reversing Content:
- `reverse()`
- Reverses the characters in the `StringBuilder`.
builder.reverse();
6. Capacity Management:
- `capacity()`
- Returns the current capacity of the `StringBuilder`.
int capacity = builder.capacity();
- `ensureCapacity(int minCapacity)`
- Ensures that the capacity of the `StringBuilder` is at least equal to the specified minimum capacity.
builder.ensureCapacity(50);
7. Converting to String:
- `toString()`
- Converts the `StringBuilder` to a `String`.
String result = builder.toString();
Example Usage:
// Creating a StringBuilder
StringBuilder builder = new StringBuilder();
// Appending content
builder.append("Hello");
builder.append(" World");
// Inserting content
builder.insert(5, " Java");
// Deleting content
builder.delete(6, 11);
// Reversing content
builder.reverse();
// Converting to String
String result = builder.toString();
The `StringBuilder` class provides a non-synchronized alternative to `StringBuffer` for situations where thread safety is not a concern, offering better performance in such scenarios.
Comments
Post a Comment