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(); ...
The `Arrays` class in Java provides various utility methods for working with arrays. Here are some key points:
1. Utility Methods: The `Arrays` class contains various static methods for sorting, searching, and filling arrays, among other operations.
2. Sorting: The `sort()` method is used to sort arrays in ascending order. There are overloaded versions of this method for sorting arrays of different data types.
3. Searching: The `binarySearch()` method is used to search for an element in a sorted array. It returns the index of the element if found, otherwise, it returns a negative value.
4. Comparing Arrays: The `equals()` method compares two arrays to determine if they are equal, i.e., if they have the same elements in the same order.
5. Filling Arrays: The `fill()` method is used to fill an array with a specified value.
6. Converting Arrays to Strings: The `toString()` method converts an array to a string representation.
7. Working with Streams: The `stream()` method returns a stream of elements from the array, which can be further processed using Java Stream API.
8. Parallel Sorting: The `parallelSort()` method sorts the specified array in parallel using the Java fork/join framework, which can be beneficial for large arrays.
Here's a simple example demonstrating the usage of some of these methods:
import java.util.Arrays;
public class ArraysExample {
public static void main(String[] args) {
int[] numbers = {5, 2, 8, 1, 3};
// Sorting
Arrays.sort(numbers);
System.out.println("Sorted array: " + Arrays.toString(numbers));
// Searching
int index = Arrays.binarySearch(numbers, 3);
System.out.println("Index of 3: " + index);
// Comparing arrays
int[] anotherArray = {1, 2, 3, 5, 8};
boolean isEqual = Arrays.equals(numbers, anotherArray);
System.out.println("Arrays are equal: " + isEqual);
// Filling array
int[] filledArray = new int[5];
Arrays.fill(filledArray, 10);
System.out.println("Filled array: " + Arrays.toString(filledArray));
}
}
Output:
Sorted array: [1, 2, 3, 5, 8]
Index of 3: 2
Arrays are equal: true
Filled array: [10, 10, 10, 10, 10]
These methods make working with arrays in Java more convenient and efficient.
Comments
Post a Comment