Java Array Methods

Java's Arrays class in the java.util package offers a range of static methods facilitating operations on arrays. It provides functionality to fill, sort, search, and more. The methods enhance array manipulation, contributing to cleaner and more efficient code.

Let's examine the operations provided by the Arrays class by reviewing its methods presented below in a tabular format.

Method	Description
asList()	The asList() method in Java is a static method defined in the Arrays class that converts an array into a fixed-size list. The method returns a list with the original array as its backing. It indicates that any changes to the list will be reflected in the original array as well.
binarySearch()	Utilizes the binary search algorithm to efficiently locate a specified value within a sorted array. Returns the index of the target value if found, or a negative value indicating the insertion point if not found.
binarySearch(array, fromIndex, toIndex, key, Comparator)	Performs a binary search within a specified range of a sorted array using a custom comparator. The fromIndex and toIndex parameters define the inclusive range of the search.
compare(array 1, array 2)	The compare() method in Java is a static method defined in the Arrays class that compares two arrays of the same data type lexicographically.
copyOf(originalArray, newLength)	The copyOf method in java.util.Arrays duplicates an array, adjusting its length to a specified size by truncating or padding with default values as necessary.
copyOfRange(originalArray, fromIndex, endIndex)	The copyOfRange(originalArray, fromIndex, toIndex) method in java.util.Arrays creates a new array by copying elements from the original array within the specified range, starting from fromIndex (inclusive) and ending at toIndex (exclusive).
deepEquals(Object[] a1, Object[] a2)	The deepEquals() method in Java is a static method defined in the Arrays class that checks whether two arrays of objects are deeply equal to one another. If two arrays are deeply identical, they are either null or have the same number of elements and all corresponding pairs of elements remain deeply equal.
deepHashCode(Object[] a)	Java computes a hash code based on the "deep contents" of the specified array. It suggests that the hashCode() function considers the hash codes of individual elements in the array, encompassing the hash codes of any nested arrays contained within those elements.
deepToString(Object[] a)	The deepToString(Object[] a) method in java.util.Arrays generates a string representation of the specified array.
equals(array1, array2)	The Arrays.equals() method in Java checks if two arrays, whether containing objects or primitive types, are equal. It looks at each pair of elements in the arrays, considering them equal only if the arrays have the same length and each pair of elements matches.
fill(originalArray, fillValue)	The fill value is assigned to each index of this array.
hashCode(originalArray)	The hashCode(originalArray) method in java.util.Arrays generates a hash code for the specified array.
mismatch(array1, array2)	The Arrays.mismatch() method in Java finds and returns the index of the first mismatch between two Object arrays. If there is no difference identified between the elements being compared, the method returns -1.
parallelPrefix(originalArray, fromIndex, endIndex, functionalOperator)	The parallelPrefix() method in Java is a static method defined in the Arrays class that performs a parallel prefix operation on a specified range of an array using a custom functional operator.
parallelPrefix(originalArray, operator)	The parallelPrefix() method in Java is a static method defined in the Arrays class that performs a parallel prefix operation on the entire array using a custom functional operator.
parallelSetAll(originalArray, functionalGenerator)	The parallelSetAll() method in Java is a static method defined in the Arrays class that sets all elements of an array in parallel using a provided generator function to compute each element.
parallelSort(originalArray)	The parallelSort() method in Java is a static method defined in the Arrays class that sorts an array in parallel using the merge sort algorithm.
setAll(originalArray, functionalGenerator)	The setAll() method in Java is a static method defined in the Arrays class that sets all elements of an array in parallel using a provided generator function to compute each element.
sort(originalArray)	The sort(originalArray) method in java.util.Arrays performs an ascending-order sort on the entire array (originalArray).
sort(originalArray, fromIndex, endIndex)	The sort(originalArray, fromIndex, endIndex) method in Java is a static method defined in the Arrays class that sorts a specified range of an array in place using a ascending function.
sort(T[] a, int fromIndex, int toIndex, Comparator< super T> c)	The sort(T[] a, int fromIndex, int toIndex, Comparator< super T> c) method in Java is a static method defined in the Arrays class that sorts a specified range of an array of objects according to the order induced by the specified comparator.
sort(T[] a, Comparator< super T> c)	The sort(T[] a, Comparator< super T> c) method in Java is a static method defined in the Arrays class that sorts an entire array of objects according to the order induced by the specified comparator.
spliterator(originalArray)	The spliterator(originalArray) method in Java is a static method defined in the Arrays class that returns a Spliterator for the specified array.
spliterator(originalArray, fromIndex, endIndex)	The spliterator(originalArray, fromIndex, endIndex) method in Java is a static method defined in the Arrays class that returns a Spliterator for the specified range of the array.
stream(originalArray)	The toString(originalArray) method in Java is a static method defined in the Arrays class that returns a string representation of the specified array.
toString(originalArray)	The toString(originalArray) method in java.util.Arrays provides a string representation of the array's contents. The resulting string showcases the array elements enclosed in square brackets and separated by commas. Each element is converted to a string using String.valueOf(), making it a handy representation for display or debugging.

Implementation:

Example 1

In the following program, we have used the asList(), binarySearch(), compare(), and the compareUnsigned() method.

Filename: ArrayMethodsExample1.java

import java.util.Arrays;
import java.util.Comparator;

public class ArrayMethodsExample1 {

    public static void main(String[] args) {
        // Method 1: asList()
        Integer[] array = {1, 4, 7, 10, 13};
        System.out.println("Original Array: " + Arrays.asList(array));

        // Method 2: binarySearch()
        int keyToSearch = 7;
        int index = Arrays.binarySearch(array, keyToSearch);
        System.out.println("Index of " + keyToSearch + ": " + index);

        // Method 3: binarySearch(array, fromIndex, toIndex, key, Comparator)
        int fromIndex = 1;
        int toIndex = 4;
        int keyToSearchInRange = 10;
        Comparator<Integer> comparator = Comparator.naturalOrder();
        int indexInRange = Arrays.binarySearch(array, fromIndex, toIndex, keyToSearchInRange, comparator);
        System.out.println("Index of " + keyToSearchInRange + " in range [" + fromIndex + ", " + toIndex + "]: " + indexInRange);

        // Method 4: compare(array1, array2)
        Integer[] array1 = {1, 2, 3};
        Integer[] array2 = {1, 2, 3};
        int comparisonResult = Arrays.compare(array1, array2);
        System.out.println("Comparison result between array1 and array2: " + comparisonResult);

        // Method 5: compareUnsigned(array1, array2)
        int[] unsignedArray1 = {Integer.MAX_VALUE, Integer.MIN_VALUE};
        int[] unsignedArray2 = {Integer.MAX_VALUE, Integer.MAX_VALUE};
        int unsignedComparisonResult = Arrays.compareUnsigned(unsignedArray1, unsignedArray2);
        System.out.println("Unsigned comparison result between unsignedArray1 and unsignedArray2: " + unsignedComparisonResult);
    }
}

Output:

Original Array: [1, 4, 7, 10, 13]
Index of 7: 2
Index of 10 in range [1, 4]: 3
Comparison result between array1 and array2: 0
Unsigned comparison result between unsignedArray1 and unsignedArray2: 1

Example 2

In the following program, we have used the copyOf(), copyOfRange(), deepEquals(), deepHashCode(), and deepToString() method.

Filename: ArrayMethodsExample2.java

import java.util.Arrays;

public class ArrayMethodsExample2 {

    public static void main(String[] args) {
        // Original array
        int[] originalArray = {1, 2, 3, 4, 5};

        // Method 6: copyOf(originalArray, newLength)
        int newLength = 7;
        int[] copyArray = Arrays.copyOf(originalArray, newLength);
        System.out.println("Copy of originalArray with new length: " + Arrays.toString(copyArray));

        // Method 7: copyOfRange(originalArray, fromIndex, endIndex)
        int fromIndex = 1;
        int toIndex = 4;
        int[] copyRangeArray = Arrays.copyOfRange(originalArray, fromIndex, toIndex);
        System.out.println("Copy of originalArray from index " + fromIndex + " to " + toIndex + ": " + Arrays.toString(copyRangeArray));

        // Method 8: deepEquals(Object[] a1, Object[] a2)
        Integer[] array1 = {1, 2, 3};
        Integer[] array2 = {1, 2, 3};
        boolean areEqual = Arrays.deepEquals(new Object[]{array1}, new Object[]{array2});
        System.out.println("Are array1 and array2 deepEquals? " + areEqual);

        // Method 9: deepHashCode(Object[] a)
        int deepHashCode = Arrays.deepHashCode(new Object[]{array1});
        System.out.println("Deep hash code of array1: " + deepHashCode);

        // Method 10: deepToString(Object[] a)
        String deepToString = Arrays.deepToString(new Object[]{array1});
        System.out.println("Deep string representation of array1: " + deepToString);
    }
}

Output:

Copy of originalArray with new length: [1, 2, 3, 4, 5, 0, 0]
Copy of originalArray from index 1 to 4: [2, 3, 4]
Are array1 and array2 deepEquals? true
Deep hash code of array1: 30848
Deep string representation of array1: [[1, 2, 3]]

Example 3

In the following program, we have used the equals(), fill(), hashCode(), mismatch(), and parallelSort() method.

Filename: ArrayMethodsExample3.java

import java.util.Arrays;

public class ArrayMethodsExample3 {

    public static void main(String[] args) {
        // Method 11: equals(array1, array2)
        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};
        boolean arraysEqual = Arrays.equals(array1, array2);
        System.out.println("Are array1 and array2 equal? " + arraysEqual);

        // Method 12: fill(originalArray, fillValue)
        int[] originalArray = new int[5];
        int fillValue = 7;
        Arrays.fill(originalArray, fillValue);
        System.out.println("Filled array with value " + fillValue + ": " + Arrays.toString(originalArray));

        // Method 13: hashCode(originalArray)
        int arrayHashCode = Arrays.hashCode(originalArray);
        System.out.println("Hash code of the array: " + arrayHashCode);

        // Method 14: mismatch(array1, array2)
        int[] mismatchArray1 = {1, 2, 3, 4, 5};
        int[] mismatchArray2 = {1, 2, 3, 6, 5};
        int mismatchIndex = Arrays.mismatch(mismatchArray1, mismatchArray2);
        System.out.println("Mismatch index between mismatchArray1 and mismatchArray2: " + mismatchIndex);

        // Method 15: parallelSort(originalArray)
        int[] unsortedArray = {5, 3, 1, 4, 2};
        Arrays.parallelSort(unsortedArray);
        System.out.println("Sorted array using parallelSort: " + Arrays.toString(unsortedArray));
    }
}

Output:

Are array1 and array2 equal? true
Filled array with value 7: [7, 7, 7, 7, 7]
Hash code of the array: 35309286
Mismatch index between mismatchArray1 and mismatchArray2: 3
Sorted array using parallelSort: [1, 2, 3, 4, 5]

Example 4

In the following program, we have used the various types of the sort() method and the spliterator method.

Filename: ArrayMethodsExample4.java

import java.util.Arrays;
import java.util.Comparator;
import java.util.Spliterator;

public class ArrayMethodsExample4 {

    public static void main(String[] args) {
        // Method 16: sort(originalArray)
        int[] originalArray = {5, 3, 1, 4, 2};
        Arrays.sort(originalArray);
        System.out.println("Sorted array using sort(): " + Arrays.toString(originalArray));

        // Method 17: sort(originalArray, fromIndex, endIndex)
        int[] partialArray = {5, 3, 1, 4, 2};
        int fromIndex = 1;
        int toIndex = 4;
        Arrays.sort(partialArray, fromIndex, toIndex);
        System.out.println("Partially sorted array from index " + fromIndex + " to " + toIndex + ": " + Arrays.toString(partialArray));

        // Method 18: sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
        String[] stringArray = {"Banana", "Apple", "Orange", "Grapes"};
        Comparator<String> lengthComparator = Comparator.comparingInt(String::length);
        Arrays.sort(stringArray, 0, stringArray.length, lengthComparator);
        System.out.println("Sorted string array by length: " + Arrays.toString(stringArray));

        // Method 19: sort(T[] a, Comparator<? super T> c)
        Integer[] customArray = {5, 3, 1, 4, 2};
        Comparator<Integer> reverseOrderComparator = Comparator.reverseOrder();
        Arrays.sort(customArray, reverseOrderComparator);
        System.out.println("Sorted array in reverse order: " + Arrays.toString(customArray));

        // Method 20: spliterator(originalArray)
        Spliterator.OfInt spliterator = Arrays.spliterator(originalArray);
        System.out.println("Spliterator characteristics: " + spliterator.characteristics());
    }
}

Output:

Sorted array using sort(): [1, 2, 3, 4, 5]
Partially sorted array from index 1 to 4: [5, 1, 3, 4, 2]
Sorted string array by length: [Apple, Banana, Orange, Grapes]
Sorted array in reverse order: [5, 4, 3, 2, 1]
Spliterator characteristics: 17488

Example 5

In the following program, we have used the spliterator(), stream(), and the toString() method.

Filename: ArrayMethodExample5.java

import java.util.Arrays;
import java.util.Spliterator;
import java.util.stream.IntStream;

public class ArrayMethodExample5 {

    public static void main(String[] args) {
        // Method 21: spliterator(originalArray, fromIndex, endIndex)
        int[] originalArray = {1, 2, 3, 4, 5};
        Spliterator.OfInt spliterator = Arrays.spliterator(originalArray, 1, 4);
        System.out.println("Spliterator characteristics: " + spliterator.characteristics());

        // Method 22: stream(originalArray)
        IntStream intStream = Arrays.stream(originalArray);
        System.out.println("IntStream from originalArray: ");
        intStream.forEach(System.out::println);

        // Method 23: toString(originalArray)
        String arrayToString = Arrays.toString(originalArray);
        System.out.println("String representation of originalArray: " + arrayToString);
    }
}

Output:

Spliterator characteristics: 17488
IntStream from originalArray: 
1
2
3
4
5
String representation of originalArray: [1, 2, 3, 4, 5]

Next Topicjava.lang.Class class in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Java Tutorial

Control Statements

Java Object Class

Java Inheritance

Java Polymorphism

Java Abstraction

Java Encapsulation

Java Array

Java OOPs Misc

Java Array Methods

Implementation:

Example 1

Example 2

Example 3

Example 4

Example 5

Feedback

Help Others, Please Share

Learn Latest Tutorials

Preparation

Trending Technologies

B.Tech / MCA