The Arrays Class In Java

1. Introduction

Arrays is a utility class from the Java Collections API. The class contains various methods for array manipulation. In this tutorial, you will learn some of these methods.

2. Convert an array to a List

One of the most used scenarios is turning an array into a List. This is because the List interface provides many useful methods as compared to the simple array.

        Integer[] anIntArray = {1,2,3,4,5};
        List<Integer> listOfIntegers = Arrays.asList(anIntArray);

Note that for this to work, the items in the array must be of type object. If you are working with primitive types, you can use the associated wrapper classes.
The following code will not compile:

        int[] anIntArray = {1,2,3,4,5};
        List<Integer> listOfIntegers = Arrays.asList(anIntArray);//Does not compile

Beware of the following important points:

• Fixed-size: The List returned by this method is backed by the input array. This means that you can't add any new element to the list. Any attempt to add or remove an element will throw an UnsupportedOperationException.
• Mutability: The list is backed by the input array. Any change in the list will reflect in the array, and vice-versa.

        Integer[] anIntArray = {1,2,3,4,5};
        List<Integer> listOfIntegers = Arrays.asList(anIntArray);
        //listOfIntegers.add(6);//UnsupportedOperationException
        listOfIntegers.replaceAll(i -> 2*i);
        System.out.println(listOfIntegers);//[2, 4, 6, 8, 10]
        System.out.println(anIntArray[4]);//10
        anIntArray[4] = 20;
        System.out.println(listOfIntegers.get(4));//20

3. Display an Array

As we saw in this tutorial, if you try to print an array to the console using System.out.println(myArray), Java will print a String corresponding to the memory address of your array. Hopefully, the Arrays class has a toString() method which provides a convenient way to display the content of an array.

        int[] anIntArray = {1,2,3,4,5};
        System.out.println(Arrays.toString(anIntArray));

4. Copy from Source to Destination

Another use case is copying the value of an array to another array. Like many other methods in the Arrays class, the copyOf() method is overloaded. This allows you to call it with any array type. The method accepts the original array as an input, and an integer denoting the size of the new array. If the integer is less than the original array size, the array is truncated. If on the contrary, it is greater than the original array size, the new array is padded with 0s.

        int[] originalInArray = {1,2,3,4,5};
        int[] copy1 = Arrays.copyOf(originalInArray,5);
        System.out.println(Arrays.toString(copy1));// [1, 2, 3, 4, 5]
        int[] copy2 = Arrays.copyOf(originalInArray,3);
        System.out.println(Arrays.toString(copy2));// [1, 2, 3]
        int[] copy3 = Arrays.copyOf(originalInArray,10);
        System.out.println(Arrays.toString(copy3));// [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]

5. Sort an Array

The Arrays class provides you with many methods to sort an array. The only condition is that the items in the array must either be primitive types or implement the Comparable interface.

5.1. Sort an Array of Primitives

        int[] anIntArray = {4,3,1,5,2};
        Arrays.sort(anIntArray);
        System.out.println(Arrays.toString(anIntArray));//[1, 2, 3, 4, 5]

5.1. Sort an Array of Objects

Below is an example with an object type Person.

        Person p1 = new Person("John", "Doe");
        Person p2 = new Person("Alice", "Smith");
        Person p3 = new Person("John", "Smith");
        Person[] persons = {p1,p2,p3};
        Arrays.sort(persons);
        System.out.println(Arrays.toString(persons));

Output:

[Person[firstName=Alice, lastName=Smith], Person[firstName=John, lastName=Doe], Person[firstName=John, lastName=Smith]]

Note that for this to work, the Person class implements the Comparable interface.

record Person(String firstName, String lastName) implements Comparable<Person>{
    @Override
    public int compareTo(Person other) {
        // Compare by firstName first
        int firstNameComparison = this.firstName.compareTo(other.firstName);
        if (firstNameComparison != 0) {
            return firstNameComparison;
        }
        // If firstName is the same, compare by lastName
        return this.lastName.compareTo(other.lastName);
    }
}

6. Miscellaneous methods

The Arrays utility class contains other useful methods among which: equals, binarySearch, compare, etc.

        int[] anIntArray1 = {1,2,3,4,5};
        int[] anIntArray2 = {4,3,1,5,2};
        int[] anIntArray3 = {1,2,3,4,5};
        System.out.println(Arrays.equals(anIntArray1,anIntArray2));//false
        System.out.println(Arrays.equals(anIntArray1,anIntArray3));//true
        int pos = Arrays.binarySearch(anIntArray1,5);
        System.out.println(pos);//4

Take away: The Arrays class provides very useful utility methods for array manipulation.

7. Conclusion

In this article, you learned some of the most used methods of the Arrays utility class.
You can find the complete code of this article here in GitHub.

_Originally published at https://nkamphoa.com