What are new methods have added to the Arrays class in Java 9?

In this article, we will learn about the new methods that have been added to the Arrays class in Java 9. First, we will learn about arrays, and then the new methods added to the equals(), compare(), and mismatch() methods with examples.

Arrays

Java provides a data structure called the Array, and they are used to store multiple values of the same datatype in a single variable. The Arrays class can contain various methods for manipulating arrays and also contains static factory methods that allow arrays to view as a list.

Creating an instance of an Array with a variable named "arrayRefVar":

arrayRefVar = new dataType[arraySize];    

New Methods in the Array Class

Java 9 has added three important methods to the Arrays class:

• Arrays.equals()
• Arrays.compare()
• Arrays.mismatch()

Arrays.equal()

The equal() method comes in java.util.Arrays class. The equals() method checks whether two arrays are equal, and handles arrays of different data types, like int, char, double, and Object.

In Java 9, a few overloaded methods have been added to the Arrays.equals() method. The new methods take fromIndex and toIndex parameters for the two provided arrays. These methods check the equality of the two arrays based on their relative index positions.

This method returns true if the two arrays are equal, else it returns false.

Syntax

The following is the syntax for the Arrays.equal() method declaration:

public static boolean equals(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

In the above syntax, the method returns true if two specified arrays of ints and over the specified ranges are equal to each other. The second method works the same for an array of chars.

Example

Below is an example of the Arrays.equal() method in Java:

import java.util.Arrays;
public class CompareArrayTest {
   public static void arrayEqualsTest() {
      int[] existRows = {0, 1, 2, 3, 4, 5};
      int[] newRows = {3, 4, 5, 1, 2, 0};
      System.out.println(Arrays.equals(existRows, newRows));
      System.out.println(Arrays.equals(existRows, 1, 3, newRows, 3, 5));
      System.out.println(Arrays.equals(existRows, 3, 5, newRows, 0, 2));
   }
   public static void main(String args[]) {
      CompareArrayTest.arrayEqualsTest();
   }
}

Output

false
true
true

Arrays.compare()

The compare() method comes in java.util.Arrays class. The compare() method compares two arrays lexicographically. This method can be used for arrays of various types, such as boolean, byte, char, etc.

In Java 9, a few parameters have been added to the Arrays.compare() method. With the fromIndex/toIndex parameters that are used for relative position comparison.

This method returns 0 if the arrays are equal, a negative integer(-1) if the first array is lexicographically less, and a positive integer(1) if the first array is lexicographically greater.

Syntax

The following is the syntax for the Arrays.compare() method declaration:

public static int compare(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

In the above syntax, the method compares two int arrays lexicographically over the specified ranges.

Example

Below is an example of the Arrays.compare() method in Java:

import java.util.Arrays;
public class LexicographicalArraysTest {
   public static void main(String args[]) {
      LexicographicalArraysTest.compareSliceArraysTest();
   }
   public static void compareSliceArraysTest() {
      int[] tomMarks = {5, 6, 7, 8, 9, 10};
      int[] daisyMarks = {5, 6, 7, 10, 9, 10};
      int[] maryMarks = {5, 6, 7, 8};
      System.out.println(Arrays.compare(tomMarks, 0, 3, daisyMarks, 0, 3));
      System.out.println(Arrays.compare(tomMarks, 0, 4, maryMarks, 0, maryMarks.length));
      System.out.println(Arrays.compare(daisyMarks, 0, 4, maryMarks, 0, maryMarks.length));
   }
}

Output

0
0
1

Arrays.mismatch()

The mismatch() method comes in java.util.Arrays class and this method are used to find the first index at which two arrays differ.

In Java 9, there are other overloaded methods of the Arrays.mismatch() method that enables us to find and return the index of the first mismatch between two slices of arrays.

This method returns the index of the first mismatch between the two arrays, else it returns -1.

Syntax

The following is the syntax for the Arrays.mismatch() method declaration:

public static int mismatch(int[] a, int aFromIndex, int aToIndex, int[] b, int bFromIndex, int bToIndex)

In the above syntax, the method finds and returns the relative index of the first mismatch between two int arrays over the specified range. It returns -1 if no mismatch has found. The index in the range of 0 (inclusive) up to the length (inclusive) of the smaller range.

Example

Below is an example of the Arrays.mismatch() method in Java:

import java.util.Arrays;
public class MismatchMethodTest {
   public static void main(String[] args) {
      MismatchMethodTest.mismatchArraysTest();
   }
   public static void mismatchArraysTest() {
      int[] a = {1, 2, 3, 4, 5};
      int[] b = {1, 2, 3, 4, 5};
      int[] c = {1, 2, 4, 4, 5, 6};
      System.out.println(Arrays.mismatch(a, b));
      System.out.println(Arrays.mismatch(a, c));
      System.out.println(Arrays.mismatch(a, 0, 2, c, 0, 2));
      System.out.println(Arrays.mismatch(a, 0, 3, c, 0, 3));
      System.out.println(Arrays.mismatch(a, 2, a.length, c, 2, 5));
   }
}

Output

-1
2
-1
2
0