In Java, arrays themselves don't have methods since they are simple objects that just hold data. However, the java.util.Arrays class provides a variety of static methods to perform operations on arrays such as sorting, searching, copying, and filling. Below are some commonly used methods from the Arrays class:

1. Arrays.sort()

This method is used to sort the elements of an array.

import java.util.Arrays;public class SortArrayExample {    public static void main(String[] args) {        int[] numbers = {5, 3, 8, 1, 2};        // Sorting the array        Arrays.sort(numbers);        // Printing the sorted array        System.out.println(Arrays.toString(numbers));  // Output: [1, 2, 3, 5, 8]    }}

2. Arrays.fill()

This method is used to fill an array with a specific value.

import java.util.Arrays;public class FillArrayExample {    public static void main(String[] args) {        int[] numbers = new int[5];        // Filling the array with the value 10        Arrays.fill(numbers, 10);        // Printing the filled array        System.out.println(Arrays.toString(numbers));  // Output: [10, 10, 10, 10, 10]    }}

3. Arrays.copyOf()

This method is used to create a new array that is a copy of the specified array, but with a different length. If the new length is larger, the new elements are initialized to the default value (0 for numeric types, null for objects).

import java.util.Arrays;public class CopyArrayExample {    public static void main(String[] args) {        int[] original = {1, 2, 3, 4, 5};        // Copying the array with a new size        int[] copy = Arrays.copyOf(original, 7);  // New array size 7        // Printing the copied array        System.out.println(Arrays.toString(copy));  // Output: [1, 2, 3, 4, 5, 0, 0]    }}

4. Arrays.copyOfRange()

This method creates a new array by copying a range of elements from the original array. It takes two arguments, the starting index (inclusive) and the ending index (exclusive).

import java.util.Arrays;public class CopyArrayRangeExample {    public static void main(String[] args) {        int[] numbers = {10, 20, 30, 40, 50};        // Copying elements from index 1 to 3 (exclusive)        int[] rangeCopy = Arrays.copyOfRange(numbers, 1, 4);        // Printing the copied range        System.out.println(Arrays.toString(rangeCopy));  // Output: [20, 30, 40]    }}

5. Arrays.equals()

This method checks if two arrays are equal, meaning they have the same elements in the same order.

import java.util.Arrays;public class ArraysEqualsExample {    public static void main(String[] args) {        int[] arr1 = {1, 2, 3, 4};        int[] arr2 = {1, 2, 3, 4};        int[] arr3 = {4, 3, 2, 1};        // Checking if arr1 and arr2 are equal        System.out.println(Arrays.equals(arr1, arr2));  // Output: true        // Checking if arr1 and arr3 are equal        System.out.println(Arrays.equals(arr1, arr3));  // Output: false    }}

6. Arrays.toString()

This method converts an array to a string representation.

import java.util.Arrays;public class ArraysToStringExample {    public static void main(String[] args) {        int[] numbers = {1, 2, 3, 4, 5};        // Converting the array to a string and printing it        System.out.println(Arrays.toString(numbers));  // Output: [1, 2, 3, 4, 5]    }}

7. Arrays.asList()

This method converts an array into a List. This is particularly useful when you want to work with arrays as lists, for example, to use Java's Collection Framework features.

import java.util.Arrays;import java.util.List;public class ArraysAsListExample {    public static void main(String[] args) {        String[] fruits = {"Apple", "Banana", "Cherry"};        // Converting array to a List        List<String> fruitList = Arrays.asList(fruits);        // Printing the List        System.out.println(fruitList);  // Output: [Apple, Banana, Cherry]    }}

Note: The list created by Arrays.asList() is backed by the original array. So changes to the list will reflect in the array and vice versa, but the size of the list cannot be changed (i.e., you can't add or remove elements).

8. Arrays.binarySearch()

This method is used to search for an element in a sorted array. It returns the index of the element if found, or a negative value if the element is not found.

import java.util.Arrays;public class BinarySearchExample {    public static void main(String[] args) {        int[] numbers = {1, 2, 3, 4, 5};        // Searching for element 3        int index = Arrays.binarySearch(numbers, 3);        // Printing the index        System.out.println("Element found at index: " + index);  // Output: 2    }}

9. Arrays.sort() with a Custom Comparator

You can use Arrays.sort() to sort arrays with custom sorting logic by providing a Comparator.

import java.util.Arrays;import java.util.Comparator;public class ArraysSortCustomComparator {    public static void main(String[] args) {        String[] fruits = {"Banana", "Apple", "Cherry"};        // Sorting the array in reverse order (descending)        Arrays.sort(fruits, Comparator.reverseOrder());        // Printing the sorted array        System.out.println(Arrays.toString(fruits));  // Output: [Cherry, Banana, Apple]    }}

10. Arrays.stream()

This method returns a Stream backed by the specified array, which allows you to perform functional-style operations like filtering, mapping, etc.

import java.util.Arrays;public class ArraysStreamExample {    public static void main(String[] args) {        int[] numbers = {1, 2, 3, 4, 5};        // Using streams to filter even numbers and print them        Arrays.stream(numbers)              .filter(n -> n % 2 == 0)              .forEach(System.out::println);  // Output: 2, 4    }}

Summary of Common Arrays Methods

These are the most commonly used methods in the Arrays class to handle array-related tasks in Java. If you need more examples or have specific questions, feel free to ask! ?