Java Array Class Tutorial – java.util.Arrays Class with Examples

This Tutorial Covers the Array Class in Java and the methods of java.util.arrays Class along with Detailed Description & Examples of Array Class methods:

The ‘Arrays’ class is a member of the ‘java.util’ package. This is a part of the Java Collections framework and provides methods to create, access and manipulate Java arrays dynamically.

All the methods provided by the Arrays class are static in nature and are methods of the ‘Object’ class. As the methods are static, they can be accessed using the class name itself.

=> Check ALL Java Tutorials Here.

Java Array Class

The Arrays class was introduced in Java 1.2 and the methods it contains are mostly used for manipulation of the array including searching, sorting, etc. The arrays class provides overloaded methods for almost all the data types.

The class hierarchy for Arrays class is shown below:

The Arrays class extends from Object class and its methods are methods of Object class.

The general syntax to access any method of Arrays class is:

Arrays.<method_name>;

In the upcoming section, we will list out the various methods provided by the Arrays class.

Java Arrays Methods

The following tables give an introduction to the various methods provided by the Arrays class. Here we have listed the main methods. Note that most of the methods are overloaded to provide support for all the primitive types.

We will list the prototype and description of each of the functions. Then in the following section, we will describe some of the important methods by providing programming examples.

The above tables shows all the methods the Arrays class provides. Most of these are overloaded for various primitive types.

Let’s discuss some of these methods in detail.

#1) asList

Prototype: static <T> List<T> asList (Object[] a)
Parameters: a – array of objects from which the list will be backed.
Return Value: List<T> => fixed-size list of specified array

Description: Returns a fixed-size serializable list backed by an array provided as an argument.

Example:

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

public class Main {
	public static void main(String[] args) {
		String[] months = {"January", "February", "March", "April", "May"};
		// converted string array to a List using asList
		System.out.println("The string array converted to list:");	
		List<String> month_list = Arrays.asList(months);
		System.out.println(month_list);
	}
}

Output:

The above program demonstrates the usage of the ‘asList’ method of Arrays class. Here, we have declared a string array and passed it to asList method to obtain a list.

#2) binarySearch

Prototype: static int binarySearch (int[] a, int key)

Parameters:

a => array in which the key is to be searched
Key=> element value to be searched

Return Value: int=>position (index) at which key is found, else returns (-(the “insertion point”) – 1).

Description: Searches for the specified key in the given array using a binary search algorithm. The array needs to be sorted for the binary search to work. If the array is not sorted then the results are undefined. Also, if there are multiple locations in the array for the same key value, the position returned is not guaranteed.

Example:

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

public class Main { 
    public static void main(String[] args) 
    { 
        // define the Array 
        int numArr[] = { 23,43,26,65,35,16,74,27,98 }; 
        //sort the array first
        Arrays.sort(numArr); 
        System.out.println("Input array:" + Arrays.toString(numArr));

         int key = 35; 
        //call binarySearch function to search a given key
         System.out.println("Key " + key + " found at index = " + Arrays 
                                 .binarySearch(numArr, key)); 
    } 
}

Output:

In the above program first, we sort the input array since for binarySearch the array should be sorted. Then the array and the key to be searched are passed to the ‘binarySearch’ method. The index at which the key is found is displayed in the output.

Prototype: static int binarySearch (int[] a, int fromIndex, int toIndex, int key)

Parameters:

a=> array to be searched
fromIndex=> starting index of the range over which the key is to be searched
toIndex=> the index of the last element in the range
key=> key to be searched for

Return Value: index of the key element is found in the specified range. Otherwise it returns (-(the “insertion point”) – 1).

Description: This overload of binarySearch searches for a key value in the specified range of the array and returns the index position of the key element if found. The array and therefore the range need to be sorted for binarySearch to work. If it’s not sorted, then the results are undefined.

Example:

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

public class Main {
    public static void main(String[] args)
    {
      int numArr[] = { 23,43,26,65,35,16,74,27,98 }; // define the Array
      Arrays.sort(numArr); //sort the array first
      System.out.println("Input array:" + Arrays.toString(numArr));
      int key = 35;
      //call binarySearch function to search a given key
      System.out.println("Key " + key + " found at index = " + Arrays
                 .binarySearch(numArr,3,7, key));
     }
}

Output:

The above program is the same as the previous one with a difference that in the call to binarySearch method, we have specified a range of the array in which the search is to be conducted.

#3) copyOf

Prototype: static int[] copyOf(int[] original, int newLength)

Parameters:

original=> array to be copied
newLength=> length of the copied array

Return Value: A new array copied from the original and padded or truncated with zeros depending on a specified length.

Description: Copies the array original into a new array and pads or truncates it with zeros depending on the length specified.

Example:

import java.util.Arrays; 

public class Main { 
    public static void main(String[] args) 
    { 

        // define the Array 
        String strArr[] = {"Java", "Python", "Perl", "C", "Ruby"}; 

        // print the original array 
       System.out.println("Original String Array: "
                           + Arrays.toString(strArr)); 
        //copy the array into new array using copyOf and print it
        System.out.println("Copied Array: "
                           + Arrays.toString(
                      Arrays.copyOf(strArr, 5))); 
    } 
}

Output:

The above program demonstrates the use of the ‘copyOf’ method of Arrays class that copies the given array into a new one. The above program copies the original string array into a new array.

#4) copyOfRange

Prototype: static int[] copyOfRange(int[] original, int from, int to)

Parameters:

original => array from which values in the range are to be copied
From=> first index of the range
To=> last index of the range

Return Value: New array with values from the specified range with zeros truncated or padded to obtain the desired length.

Description: Copies the range specified from a given array into a new array. The started index of the array should be inclusive between 0 to original.length. The end index can be exclusive.

Example:

import java.util.Arrays; 

public class Main { 
public static void main(String[] args) 
    { 
         // define the Array 
        String strArr[] = {"Java", "Python", "Perl", "C", "Ruby"}; 

        // print the original array 
       System.out.println("Original String Array: "  + Arrays.toString(strArr)); 
        //copy the array into new array using copyOfRange and print it
       System.out.println("Copied Range of Array: "
                  + Arrays.toString(
                         Arrays.copyOfRange(strArr,1,3))); 
    } 
}

Output:

We have modified the previous program to use the ‘copyOfRange’ method that copies a specific range from the array and forms a new array. In the above program, we have specified the range like 1, 3. Hence the output shows a new array of 2 elements.

#5) Equals

Prototype: static boolean equals (int [] a, int [] a2)

Parameters:

a=> first array to be tested for equality
A2=> second array to be tested for equality

Return Value: Returns true if both arrays are equal.

Description: This method checks if both the arrays are equal and return the results. The two arrays are said to be equal if both the arrays have an equal number of elements and the corresponding elements in both arrays are equal.

Example:

import java.util.Arrays; 

public class Main {
	public static void main(String[] args) {
		// define two arrays, array_One and array_Two
		int[] array_One = { 1, 3, 5, 7 };
		int[] array_Two = { 1, 3, 5, 7 };
		//print the arrays
		System.out.println("array_One = " + Arrays.toString(array_One));
		System.out.println("array_Two = " + Arrays.toString(array_Two));
		//use equals method to check for equality of arrays		
		booleanarray_equal = Arrays.equals(array_One, array_Two);
		//print the results
		if (array_equal) {
			System.out.println("equals method returns " + array_equal + 
			", hence arrays array_One and array_Two are equal\n");	
		}else {
			System.out.println("equals method returns " + array_equal + 
			", hence arrays array_One and array_Two are not equal\n");
		}
		// define two more arrays, firstArray&secondArray
		int[] firstArray = { 2, 4, 6, 8 };
		int[] secondArray = { 1, 3, 5, 7};
		 //display these arrays
		System.out.println("firstArray = " + Arrays.toString(firstArray));
		System.out.println("secondArray = " + Arrays.toString(secondArray));
		//use equals method to check equality of arrays		
		boolean test_array = Arrays.equals(firstArray, secondArray);
		
		//print the results
		if (test_array) {
			System.out.println("equals method returns " + test_array + 
			", hence arrays firstArray and secondArray are equal\n");	

		}else {
			System.out.println("equals method returns " + test_array + 
			", hence arrays firstArray and secondArray are not equal\n");
		}
	}
}

Output:

The above program demonstrates the ‘equals’ method. Here, we have used two sets of arrays and called ‘equals’ twice. In the first call to equals, both arrays are the same and hence the method returns true. In the second call to equals, the two arrays are different and the method returns false.

#6) Fill

Prototype: static void fill(int[] a, int val)

Parameters:

a=> array to be filled
val=> value to be filled in all places in array

Return Value: None
Description: Fills the array with the specified value.

Example:

import java.util.Arrays; 

public class Main {
	public static void main(String[] args) {
		// define the array
		int[] intArray = { 1, 3, 5, 7 };
		//print original array
		System.out.println("The original array: " + Arrays.toString(intArray));
		//call fill method to fill the array with all zeros		
		Arrays.fill(intArray, 0);
		//print altered array
		System.out.println("Array after call to fill:" + Arrays.toString(intArray));
	}		
}

Output:

The above program shows the basic version of the fill method. Here, we just fill the entire array by another value. In this case, we have filled the array with all zeros.

Prototype: static void fill(int[] a, int fromIndex, int toIndex, int val)

Parameters:

a=> array whose range is to be filled
fromIndex => start index of the range
toIndex => end index of the range
val=> value with which the elements in the range is to be filled

Return Value: None

Description: Fills the specified range from fromIndex to toIndex in the array ‘a’ with the specified value. If fromIndex = toIndex, then the range to be filled is empty.

Example:

import java.util.Arrays; 

public class Main {
	public static void main(String[] args) {
		// define the array
		int[] intArray = { 1, 3, 5, 7, 9, 11, 13, 15,17};
		//print original array
		System.out.println("The original array: " + Arrays.toString(intArray));
		//call fill method to fill the range (2,6) in the array with zeros		
		Arrays.fill(intArray, 2, 6, 0);
		//print altered array
		System.out.println("Array after call to fill the range(2,6):" + Arrays.toString(intArray));
	}		
}

Output:

This is another version of the fill method wherein, we specify the particular range in the array which is to be filled with a different value. In the above program, we have specified the range [2, 6] to be filled with zeros. The other elements remain the same as shown in the output.

#7) Sort

Prototype: static void sort(int[] a)
Parameters: a=> array to be sorted
Return Value: None
Description: This method sorts the array in ascending order.

Example:

import java.util.Arrays; 

public class Main {
	public static void main(String[] args) {
		// define the array
		int[] intArray = {10,4,25,63,21,51,73,24,87,18};
		//print original array
		System.out.println("The original array: " + Arrays.toString(intArray));
		//call sort method to sort the given array in ascending order		
		Arrays.sort(intArray);
		//print altered array
		System.out.println("Sorted array:" + Arrays.toString(intArray));
	}		
}

Output:

The above program sorts an array of integers using the sort method of Arrays class and prints the sorted array.

Prototype: static void sort(int[] a, int fromIndex, int toIndex)

Parameters:

a=> array from which a range is to be sorted
fromIndex => start index for the range
toIndex=> end index for the range

Return Value: none

Description: Sorts the range specified from fromIndex to toIndex in ascending order. If fromIndex=toIndex, then range to be sorted is empty.

Example:

import java.util.Arrays; 

public class Main {
	public static void main(String[] args) {
		// define the array
		int[] intArray = {10,4,25,63,21,51,73,24,87,18};
		//print original array
		System.out.println("The original array: " + Arrays.toString(intArray));
		//call sort method to sort the given range in the array in ascending order		
		Arrays.sort(intArray, 2, 7);
		//print altered array
		System.out.println("Sorted range(2,7) in the array:" + Arrays.toString(intArray));
	}		
}

Output:

The above program demonstrates the variation of sort method. In this, we can specify a range over which the array is to be sorted. The elements out of this range are not sorted. In the above program, the range [2,7] in the given array is specified to be sorted in the sort method.

Hence in the output, we can see that only the elements in this range are sorted in ascending order.

#8) toString

Prototype: static String toString(int[] a)
Parameters: a=> array whose string representation is required
Return Value: string=> string representation of array
Description: Converts the given array into its string representation.

Example:

import java.util.*;

public class Main
{
	public static void main(String[] args) {
		//declare arrays of type int and double
		int[] intArray = {10,20,30,40,50};
		
		double[] dblArray = {1.0,2.0,3.0,4.0,5.0};
		
		System.out.println("String representation of int Array: ");
		//print string representation of int array using toString
		System.out.println(Arrays.toString(intArray));
		
		System.out.println("\nString representation of double Array: ");
		 //print string representation of double array using toString	
		System.out.println(Arrays.toString(dblArray));
	}
}

Output:

In the above example, we have used the toString method that converts the arrays to a string representation. So to demonstrate this method, we have used two arrays each of type int and double. Then using the toString method, each of this array is converted to its corresponding string representation shown in the output.

#9) hashCode

Prototype: static int hashCode(int[] a)
Parameters: a=> array whose hashcode is to be computed.
Return Value: int=> hashcode computed

Description: The method returns the hashcode of a given array. The hashcode of a Java Object is actually a 32-bit number (signed int). Using hashcode you can manage an object using hash-based structure.

Hashcode is allocated by JVM to an object and is usually unique unless the two objects are equal to each other in which case both the objects will have the same hashcode.

Example:

import java.util.*;

public class Main
{
	public static void main(String[] args) {
		
		//declare arrays of type int
		int[] intArray = {10,20,30,40,50};
		//print the input array
		System.out.println("The input Array: " + Arrays.toString(intArray));
		//get hashcode of the array using 'hashCode' method of array
		inthashCde = Arrays.hashCode(intArray);
		//print the hashCode	
		System.out.println("The hashCode for input array:" + hashCde);
	}
}

Output:

The hashCode method computes the hashcode for the given array passed as an argument to it.

Frequently Asked Questions

Q #1) What are java.util arrays?

Answer: The class java.util.Arrays extend from the class java.lang.Object. The Arrays class contains the method to represent arrays as a list. It also contains various methods to manipulate the arrays like sorting, searching, representing arrays as strings, etc.

Q #2) Which sorting is used in arrays sort in Java?

Answer: The sort method of Arrays class in Java uses two sorting techniques. It uses quicksort when primitive types are used whereas when objects are used that implement comparable interface, merge sort is used.

Q #3) What does Arrays.sort () method do in Java?

Answer: The Arrays.sort () method in Java has various overloads using which you can perform sorting on arrays. It has overloads for sorting different primitive data type’s arrays.

In addition, the Arrays.sort () method has various overloads for sorting an array over a specified range. Apart from this, the Arrays.sort () method also allows us to sort depending on the comparator provided.

Q #4) What are collections and arrays class?

Answer: Collections are dynamic in nature and the class Collections provides direct methods that act on collections. Arrays are static in nature and have class Arrays that provide methods to manipulate arrays.

But these are not direct methods i.e. Array objects cannot invoke these methods. Instead, an array object is passed as an argument to these methods.

Conclusion

Arrays class belongs to java.util package and extends from java.lang.Object class. Arrays class contains methods that are used to manipulate arrays. These methods include those used for sorting arrays, searching for a particular element in arrays, filling the array with a specific value, methods to compare arrays, etc.

Each of these methods has various overloads that allow the programmer to invoke these methods on arrays of different data types and also on part or whole arrays.

In this tutorial, we have discussed most of the methods of arrays class. We also saw a brief description and examples of the major methods. These examples can be replicated for various data types and we leave it you.

=> Visit Here To Learn Java From Scratch.