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
In Java, the `List` interface represents an ordered collection of elements where duplicates are allowed. It extends the `Collection` interface and provides methods to access, insert, update, and remove elements. Here's an explanation along with a demonstration example:
Explanation:
1. Ordered Collection:
- Lists maintain the order of elements as they are inserted.
- Each element in a list has an index, starting from 0 for the first element.
2. Duplicates Allowed:
- Lists can contain duplicate elements, unlike sets where elements are unique.
3. Key Methods:
- `add(E element)`: Adds the specified element to the end of the list.
- `get(int index)`: Retrieves the element at the specified index.
- `set(int index, E element)`: Replaces the element at the specified position with the specified element.
- `remove(int index)`: Removes the element at the specified index.
- `size()`: Returns the number of elements in the list.
4. Common Implementations:
- `ArrayList`: Resizable-array implementation of the `List` interface.
- `LinkedList`: Doubly-linked list implementation.
- `Vector`: Synchronized resizable-array implementation (less commonly used).
Example Demonstration:
Let's demonstrate using `ArrayList`, one of the most commonly used implementations of the `List` interface.
import java.util.ArrayList;
import java.util.List;
public class ListExample {
public static void main(String[] args) {
// Creating an ArrayList
List<String> fruits = new ArrayList<>();
// Adding elements to the list
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");
fruits.add("Apple"); // Duplicates are allowed
// Accessing elements by index
System.out.println("First fruit: " + fruits.get(0));
// Iterating over the list
System.out.println("All fruits:");
for (String fruit : fruits) {
System.out.println(fruit);
}
// Removing an element
fruits.remove(1); // Removing "Banana"
// Updating an element
fruits.set(1, "Mango"); // Replacing "Banana" with "Mango"
// Size of the list
System.out.println("Number of fruits: " + fruits.size());
// Checking if a specific element is present
if (fruits.contains("Orange")) {
System.out.println("Orange is in the list.");
} else {
System.out.println("Orange is not in the list.");
}
}
}
Output:
First fruit: Apple
All fruits:
Apple
Banana
Orange
Apple
Number of fruits: 3
Orange is in the list.
In this example, we created an `ArrayList` called `fruits`, added elements, accessed elements by index, iterated over the list, removed an element, updated an element, checked the size of the list, and checked for the presence of a specific element. Lists are versatile data structures in Java, suitable for various use cases where ordered collection with duplicates is required.
Comments
Post a Comment