# Arrays Class in Java

> The `Arrays` class in Java is part of the `java.util` package and provides **utility methods** for working with arrays, including sorting, searching, comparing, and filling elements.

## **Overview of** `Arrays` Class

* The `Arrays` class is a **final** class (cannot be extended).
    
* It contains **static methods** for performing operations on arrays.
    
* It works with **primitive** and **object** arrays.
    
* Provides **enhanced** performance for array manipulations.
    

## **Commonly Used Methods in** `Arrays` Class

| Method | Description |
| --- | --- |
| `sort(array)` | Sorts the array in ascending order. |
| `binarySearch(array, key)` | Searches for a key using binary search (sorted array required). |
| `equals(arr1, arr2)` | Compares two arrays for equality. |
| `fill(array, value)` | Fills the entire array with a specific value. |
| `copyOf(array, newLength)` | Copies an array and resizes it. |
| `toString(array)` | Converts the array to a readable string format. |
| `asList(array)` | Converts an array into a `List`. |
| `hashCode(array)` | Returns a hash code based on array contents. |

---

## **Examples of** `Arrays` Class

### **Sorting an Array (**`sort()`)

The `sort()` method sorts an array in **ascending order**.

**Example - Sorting an Integer Array**

```java
import java.util.Arrays;

public class ArraysSortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 3};
        
        Arrays.sort(numbers);
        
        System.out.println(Arrays.toString(numbers)); // Output: [1, 2, 3, 5, 8]
    }
}
```

### **Sorting an Array of Strings**

```java
import java.util.Arrays;

public class StringArraySort {
    public static void main(String[] args) {
        String[] names = {"Zara", "Alice", "Bob"};
        
        Arrays.sort(names);
        
        System.out.println(Arrays.toString(names)); // Output: [Alice, Bob, Zara]
    }
}
```

### **Sorting a Subarray**

```java
javaCopyEditint[] arr = {10, 5, 20, 15, 30};
Arrays.sort(arr, 1, 4);
System.out.println(Arrays.toString(arr)); // Output: [10, 5, 15, 20, 30]
```

*Here, only elements from index* `1` to `3` (excluding `4`) are sorted.

### **Searching in an Array (**`binarySearch()`)

`binarySearch()` is used to **find an element** in a sorted array.

**Example - Finding an Element**

```javascript
import java.util.Arrays;

public class BinarySearchExample {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9};
        
        int index = Arrays.binarySearch(arr, 5);
        System.out.println("Element found at index: " + index); // Output: 2
    }
}
```

🔹 **Note:** If the element is **not found**, it returns `-(insertion point) - 1`.

### **Comparing Arrays (**`equals()`)

`equals(arr1, arr2)` checks if two arrays are **identical**.

```java
import java.util.Arrays;

public class CompareArrays {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        int[] arr3 = {3, 2, 1};

        System.out.println(Arrays.equals(arr1, arr2)); // Output: true
        System.out.println(Arrays.equals(arr1, arr3)); // Output: false
    }
}
```

---

### **Filling an Array (**`fill()`)

`fill()` assigns the **same value** to all elements in the array.

```java
import java.util.Arrays;

public class FillArray {
    public static void main(String[] args) {
        int[] arr = new int[5];

        Arrays.fill(arr, 7); // Fill all elements with 7

        System.out.println(Arrays.toString(arr)); // Output: [7, 7, 7, 7, 7]
    }
}
```

You can also fill a **specific range**:

```java
Arrays.fill(arr, 1, 4, 10);
```

This fills index `1` to `3` with `10`.

---

## **6\. Copying Arrays (**`copyOf()`, `copyOfRange()`)

* `copyOf(array, newLength)`: Creates a **new array** with a specified length.
    
* `copyOfRange(array, from, to)`: Copies a specific range.
    

```javascript
import java.util.Arrays;

public class CopyArray {
    public static void main(String[] args) {
        int[] original = {10, 20, 30, 40, 50};

        int[] copied = Arrays.copyOf(original, 3);

        System.out.println(Arrays.toString(copied)); // Output: [10, 20, 30]
    }
}
```

**Example - Copying a Range**

```javascript
int[] copiedRange = Arrays.copyOfRange(original, 1, 4);
System.out.println(Arrays.toString(copiedRange)); // Output: [20, 30, 40]
```

---

### **Converting Arrays to String (**`toString()`)

This method is used for **displaying array elements**.

**Example**

```java
import java.util.Arrays;

public class ArrayToString {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Banana", "Cherry"};

        System.out.println(Arrays.toString(fruits)); // Output: [Apple, Banana, Cherry]
    }
}
```

---

### **Converting Arrays to List (**`asList()`)

`asList()` converts an array into a **List**.

```java
import java.util.Arrays;
import java.util.List;

public class ArrayToList {
    public static void main(String[] args) {
        String[] colors = {"Red", "Green", "Blue"};

        List<String> colorList = Arrays.asList(colors);
        
        System.out.println(colorList); // Output: [Red, Green, Blue]
    }
}
```

🔹 **Note:** The list returned is **fixed-size**, meaning you cannot `add()` or `remove()` elements.

### **Generating Hash Code (**`hashCode()`)

`hashCode()` returns a **hash code** for an array, useful in **hash-based collections**.

```java
import java.util.Arrays;

public class ArrayHashCode {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};

        System.out.println(Arrays.hashCode(arr)); // Example Output: 30817
    }
}
```

### **Multidimensional Arrays Support**

The `deepToString()` and `deepEquals()` methods handle **nested arrays**.

**Converting 2D Array to String**

```javascript
import java.util.Arrays;

public class MultiDimensionalArray {
    public static void main(String[] args) {
        int[][] matrix = { {1, 2}, {3, 4} };

        System.out.println(Arrays.deepToString(matrix));
        // Output: [[1, 2], [3, 4]]
    }
}
```

## **Conclusion**

* The `Arrays` class simplifies **sorting, searching, filling, and comparing arrays**.
    
* It is a **high-performance** alternative to writing custom array operations.
    
* Ideal for **working with primitive & object arrays**.