{"id":118144,"date":"2020-04-06T10:52:41","date_gmt":"2020-04-06T10:52:41","guid":{"rendered":"https:\/\/www.softwaretestinghelp.com\/?page_id=118144"},"modified":"2025-04-01T08:29:36","modified_gmt":"2025-04-01T08:29:36","slug":"java-array-class-tutorial","status":"publish","type":"page","link":"https:\/\/www.softwaretestinghelp.com\/java-array-class-tutorial\/","title":{"rendered":"Java Array Class Tutorial – java.util.Arrays Class with Examples"},"content":{"rendered":"

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:<\/strong><\/p>\n

The \u2018Arrays\u2019 class is a member of the \u2018java.util\u2019 package. This is a part of the Java Collections framework and provides methods to create, access and manipulate Java arrays dynamically.<\/p>\n

All the methods provided by the Arrays class are static in nature and are methods of the \u2018Object\u2019 class. As the methods are static, they can be accessed using the class name itself.<\/p>\n

=> Check ALL Java Tutorials Here.<\/a><\/strong><\/p>\n

<\/strong><\/em><\/p>\n

\"Java<\/a><\/p>\n

Java Array Class<\/h2>\n

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.<\/p>\n

The class hierarchy for Arrays class is shown below:<\/strong><\/p>\n

\"class<\/a><\/p>\n

The Arrays class extends from Object class and its methods are methods of Object class.<\/p>\n

The general syntax to access any method of Arrays class is:<\/strong><\/p>\n

Arrays.&lt;method_name&gt;;<\/pre>\n
In the upcoming section, we will list out the various methods provided by the Arrays class.<\/p>\n
Java Arrays Methods<\/h2>\n
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.<\/p>\n
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.<\/p>\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
asList<\/strong><\/td>static< T> List< 
\nT>asList(Object[]\u00a0a)<\/td>		Returns a list(fixed-size) from specified array<\/td>\n<\/tr>\n
binarySearch<\/strong>
\nThis method uses the binary search algorithm.
\nShown in the next column are various overloads of the binarySearch method.<\/td>		static int binarySearch(byte[] a, byte key)<\/td>Searches for a key in a byte array <\/td>\n<\/tr>\n
static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)<\/td>Searches the key across the specified range in a byte array<\/td>\n<\/tr>\n
static int binarySearch(char[] a, char key)<\/td>Searches a key in a character array<\/td>\n<\/tr>\n
static int binarySearch(char[] a, int fromIndex, int toIndex, char key)<\/td>Searches the key across the specified range in a character array<\/td>\n<\/tr>\n
static int binarySearch(double[] a, double key)<\/td>Searches a key in a double array<\/td>\n<\/tr>\n
static int binarySearch(double[] a, int fromIndex, int toIndex, double key)<\/td>Searches the key across the specified range in a double array<\/td>\n<\/tr>\n
static int binarySearch(float[] a, float key)<\/td>Searches a key in an array of floats<\/td>\n<\/tr>\n
static int binarySearch(float[] a, int fromIndex, int toIndex, float key)<\/td>Searches the key across the specified range in a floats array<\/td>\n<\/tr>\n
static int binarySearch(int[] a, int key)<\/td>Searches a key in an int array<\/td>\n<\/tr>\n
static int binarySearch(int[] a, int fromIndex, int toIndex, int key)<\/td>Searches the key across the specified range in an int array<\/td>\n<\/tr>\n
static int binarySearch(long[] a, long key)<\/td>Searches a key in long array<\/td>\n<\/tr>\n
static int binarySearch(long[] a, int fromIndex, int toIndex, long key)<\/td>Searches the key across the specified range in long array<\/td>\n<\/tr>\n
static int binarySearch(Object[] a, Object key)<\/td>Searches a key in an object array<\/td>\n<\/tr>\n
static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key)<\/td>Searches the key across the specified range in the object array<\/td>\n<\/tr>\n
static int binarySearch(short[] a, short key)<\/td>Searches a key in an array of shorts<\/td>\n<\/tr>\n
static int binarySearch(short[] a, int fromIndex, int toIndex, short key)<\/td>Searches the key across the specified range in an array of shorts<\/td>\n<\/tr>\n
static < T> int binarySearch(T[] a, T key, Comparator< ? super T> c)<\/td>Searches a key in an array of specified objects<\/td>\n<\/tr>\n
static < T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator< ? super T> c)<\/td>Searches the key across the specified range in array of objects<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
copyOf
\n
\nThe method is used to copy the array with the specified length.
\n
\nNext column lists the overloads of this method<\/td>		static boolean[]copyOf(boolean[] original, int newLength)<\/td>Copies the specified array. Truncates or appends values \u2018false\u2019 if necessary<\/td>\n<\/tr>\n
static byte[]copyOf(byte[] original, int newLength)<\/td>Copies the specified array. Truncates or appends zeros if necessary<\/td>\n<\/tr>\n
static char[]copyOf(char[] original, int newLength)<\/td>Copies the specified array. Truncates or appends null if necessary<\/td>\n<\/tr>\n
static double[] copyOf(double[] original, int newLength)<\/td>Copies the specified array. Truncates or appends zeros if necessary<\/td>\n<\/tr>\n
static float[]copyOf(float[] original, int newLength)<\/td>Copies the specified array. Truncates or appends zeros if necessary<\/td>\n<\/tr>\n
static int[]copyOf(int[] original, int newLength)<\/td>Copies the specified array. Truncates or appends zeros if necessary<\/td>\n<\/tr>\n
static long[]copyOf(long[] original, int newLength)<\/td>Copies the specified array. Truncates or appends zeros if necessary<\/td>\n<\/tr>\n
static short[]copyOf(short[] original, int newLength)<\/td>Copies the specified array. Truncates or appends zeros if necessary<\/td>\n<\/tr>\n
static < T> T[] copyOf(T[] original, int newLength)<\/td>Copies the specified array. Truncates or appends nulls if necessary<\/td>\n<\/tr>\n
static  T[]copyOf(U[] original, int newLength, Class< ? extends T[]>newType)<\/td>Copies the specified array. Truncates or appends nulls if necessary<\/td>\n<\/tr>\n
copyOfRange
\n
\nThis method is used to copy a specified range in the array.
\n
\nThe overloads for this method are given in the next column<\/td>		static boolean[]copyOfRange(boolean[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static byte[]copyOfRange(byte[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static char[]copyOfRange(char[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static double[] copyOfRange(double[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static float[]copyOfRange(float[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static int[]copyOfRange(int[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static long[]copyOfRange(long[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static short[]copyOfRange(short[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static < T> T[] copyOfRange(T[] original, int from, int to)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n
static < T,U> T[] copyOfRange(U[] original, int from, int to, Class< ? extends T[]>newType)<\/td>Copies the array with specified range into a new array<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
deepEquals<\/strong><\/td>static boolean deepEquals(Object[] a1, Object[] a2)<\/td>Checks if two specified arrays are deeply equal<\/td>\n<\/tr>\n
deepHashCode<\/strong><\/td>static intdeepHashCode(Object[] a)<\/td>Returns a hash code of the specified array<\/td>\n<\/tr>\n
deepToString<\/strong><\/td>static StringdeepToString(Object[] a)<\/td>Returns the \"deep contents\" of the specified array in a string<\/td>\n<\/tr>\n
Equals<\/strong>
\n
\nChecks if two specified arrays are equal<\/td>		static boolean equals(boolean[] a, boolean[] a2)<\/td>Returns true if the two specified booleanarrays are equal.<\/td>\n<\/tr>\n
static boolean equals(byte[] a, byte[] a2)<\/td>Returns true if the two specified byte arrays are equal<\/td>\n<\/tr>\n
static boolean equals(char[] a, char[] a2)<\/td>Returns true if the two specified character arrays are equal.<\/td>\n<\/tr>\n
static boolean equals(double[] a, double[] a2)<\/td>Returns true if the two specified double arrays are equal.<\/td>\n<\/tr>\n
static boolean equals(float[] a, float[] a2)<\/td>Returns true if the two specified float arrays are equal.<\/td>\n<\/tr>\n
static boolean equals(int[] a, int[] a2)<\/td>Returns true if the two specified int arrays are equal.<\/td>\n<\/tr>\n
static boolean equals(long[] a, long[] a2)<\/td>Returns true if the two specified long arrays are equal.<\/td>\n<\/tr>\n
static boolean equals(Object[] a, Object[] a2)<\/td>Returns true if the two specified Object arrays are equal.<\/td>\n<\/tr>\n
static boolean equals(short[] a, short[] a2)<\/td>Returns true if the two specified short arrays are equal.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
fill<\/strong>
\n
\nFills the array(all elements) with the specified value.
\n
\nNext column gives the overloads for this function<\/td>		static void fill(boolean[] a, boolean val)<\/td>Fills the boolean array with a specified boolean value<\/td>\n<\/tr>\n
static void fill(boolean[] a, int fromIndex, int toIndex, boolean val)<\/td>Assigns a boolean value to the specified range in the boolean array.<\/td>\n<\/tr>\n
static void fill(byte[] a, byte val)<\/td>Fills the byte array with a specified byte value<\/td>\n<\/tr>\n
static void fill(byte[] a, int fromIndex, int toIndex, byte val)<\/td>Fills the byte array with specified byte value in the given range<\/td>\n<\/tr>\n
static void fill(char[] a, char val)<\/td>Fills the char array with specified char value<\/td>\n<\/tr>\n
static void fill(char[] a, int fromIndex, int toIndex, char val)<\/td>Fills the char array range with specified char value<\/td>\n<\/tr>\n
static void fill(double[] a, double val)<\/td>Fills the double array with specified double value<\/td>\n<\/tr>\n
static void fill(double[] a, int fromIndex, int toIndex, double val)<\/td>Assigns a double value to the specified range in the double array.<\/td>\n<\/tr>\n
static void fill(float[] a, float val)<\/td>Assigns float value to the specified range in the float array.<\/td>\n<\/tr>\n
static void fill(float[] a, int fromIndex, int toIndex, float val)<\/td>Assigns float value to the specified range in the float array.<\/td>\n<\/tr>\n
static void fill(int[] a, int val)<\/td>Assigns int value to the int array.<\/td>\n<\/tr>\n
static void fill(int[] a, int fromIndex, int toIndex, int val)<\/td>Assigns int value to the specified range in the int array.<\/td>\n<\/tr>\n
static void fill(long[] a, int fromIndex, int toIndex, long val)<\/td>Assigns a long value to the specified range in the long array.<\/td>\n<\/tr>\n
static void fill(long[] a, long val)<\/td>Assigns a long value to the long array.<\/td>\n<\/tr>\n
static void fill(Object[] a, int fromIndex, int toIndex, Object val)<\/td>Assigns Object reference to specified range in the Object array.<\/td>\n<\/tr>\n
static void fill(Object[] a, Object val)<\/td>Assigns Object reference to the specified objectarray<\/td>\n<\/tr>\n
static void fill(short[] a, int fromIndex, int toIndex, short val)<\/td>Assigns a short value to the specified range in the short array.<\/td>\n<\/tr>\n
static void fill(short[] a, short val)<\/td>Assigns a short value to the specified short array.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
Sort<\/strong>
\nSorts the array passed as a parameter to the method.
\nOverloads are given in the next column.
\n<\/td>		static void sort(byte[] a)<\/td>Sorts the byte array numerically<\/td>\n<\/tr>\n
static void sort(byte[] a, int fromIndex, int toIndex)<\/td>Sorts the range of elements from the array<\/td>\n<\/tr>\n
static void sort(char[] a)<\/td>Sorts the character array into ascending numerical order.<\/td>\n<\/tr>\n
static void sort(char[] a, int fromIndex, int toIndex)<\/td>Sorts the range of elements in the array into ascending order.<\/td>\n<\/tr>\n
static void sort(double[] a)<\/td>Sorts the double array into ascending numerical order.<\/td>\n<\/tr>\n
static void sort(double[] a, int fromIndex, int toIndex)<\/td>Sorts the range of elements from the array into ascending order.<\/td>\n<\/tr>\n
static void sort(float[] a)<\/td>Sorts the float array into ascending numerical order.<\/td>\n<\/tr>\n
static void sort(float[] a, int fromIndex, int toIndex)<\/td>Sorts the range of elements from the array into ascending order.<\/td>\n<\/tr>\n
static void sort(int[] a)<\/td>Sorts the int array into ascending numerical order.<\/td>\n<\/tr>\n
static void sort(int[] a, int fromIndex, int toIndex)<\/td>Sorts therange of elements from the array into ascending order.<\/td>\n<\/tr>\n
static void sort(long[] a)<\/td>Sorts the long array into ascending numerical order.<\/td>\n<\/tr>\n
static void sort(long[] a, int fromIndex, int toIndex)<\/td>Sorts the range of elements from the array into ascending order<\/td>\n<\/tr>\n
static void sort(Object[] a)<\/td>Sorts the array of objects into ascending order. Sorting is done according to the natural ordering of its elements<\/td>\n<\/tr>\n
static void sort(Object[] a, int fromIndex, int toIndex)<\/td>Sorts the specified range froman array of objects into ascending order. Sorting is done according to the natural ordering of its elements.<\/td>\n<\/tr>\n
static void sort(short[] a)<\/td>Sorts the array of type short into ascending numerical order.<\/td>\n<\/tr>\n
static void sort(short[] a, int fromIndex, int toIndex)<\/td>Sorts the range of elements from the array into ascending order.<\/td>\n<\/tr>\n
static < T> void sort(T[] a, Comparator< ? super T> c)<\/td>Sorts the specified array of objects. The order of sorting is induced as per the specified comparator.<\/td>\n<\/tr>\n
static < T> void sort(T[] a, int fromIndex, int toIndex, Comparator< ? super T> c)<\/td>Sorts the range of elementsfrom an array of objects in the order specified by the comparator.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
toString<\/strong>
\n
\nThis method returns the string representation of a given array.
\nDifferent overloads of this method are given in the next column<\/td>		static String toString(boolean[] a)<\/td>Returns a string representation of a boolean array<\/td>\n<\/tr>\n
static String toString(byte[] a)<\/td>Returns a string representation of a byte array<\/td>\n<\/tr>\n
static String toString(char[] a)<\/td>Returns a string representation of a character array<\/td>\n<\/tr>\n
static String toString(double[] a)<\/td>Returns a string representation of a double array<\/td>\n<\/tr>\n
static String toString(float[] a)<\/td>Returns a string representation of a float array<\/td>\n<\/tr>\n
static String toString(int[] a)<\/td>Returns a string representation of an int array<\/td>\n<\/tr>\n
static String toString(long[] a)<\/td>Returns a string representation of a long array<\/td>\n<\/tr>\n
static String toString(Object[] a)<\/td>Returns a string representation of an object array<\/td>\n<\/tr>\n
static String toString(short[] a)<\/td>Returns a string representation of a short array<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n\n
\n\n\n\n\t\n\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t
Method Name<\/strong><\/th>Prototype<\/strong><\/th>Description<\/strong><\/th>\n<\/tr>\n<\/thead>\n
hashCode<\/strong>
\nThis method returns the hashCode of the contents of the specified array
\nThe overloaded methods are given in the next column.
\n<\/td>		static int hashCode(boolean[] a)<\/td>Returns hash code of the contents of the boolean array<\/td>\n<\/tr>\n
static int hashCode(byte[] a)<\/td>Returns hash code of the contents of the byte array<\/td>\n<\/tr>\n
static int hashCode(char[] a)<\/td>Returns hash code of the contents of the character array<\/td>\n<\/tr>\n
static int hashCode(double[] a)<\/td>Returns hash code of the contents of a double array<\/td>\n<\/tr>\n
static int hashCode(float[] a)<\/td>Returns hash code of the contents of a float array<\/td>\n<\/tr>\n
static int hashCode(int[] a)<\/td>Returns hash code of the contents of an int array.<\/td>\n<\/tr>\n
static int hashCode(long[] a)<\/td>Returns hash code of the contents of a long array<\/td>\n<\/tr>\n
static int hashCode(Object[] a)<\/td>Returns hash code of the contents of object array<\/td>\n<\/tr>\n
static int hashCode(short[] a)<\/td>Returns hash code of the contents of the short array<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n\n
The above tables shows all the methods the Arrays class provides. Most of these are overloaded for various primitive types.<\/p>\n
Let’s discuss some of these methods in detail.<\/p>\n
#1) asList<\/span><\/h3>\n
Prototype: <\/strong>static <T> List<T> asList (Object[] a)
\nParameters: <\/strong>a – array of objects from which the list will be backed.
\nReturn Value: <\/strong>List<T> => fixed-size list of specified array<\/p>\n
Description:<\/strong> Returns a fixed-size serializable list backed by an array provided as an argument.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays;\r\nimport java.util.List;\r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\tString[] months = {"January", "February", "March", "April", "May"};\r\n\t\t\/\/ converted string array to a List using asList\r\n\t\tSystem.out.println("The string array converted to list:");\t\r\n\t\tList&lt;String&gt; month_list = Arrays.asList(months);\r\n\t\tSystem.out.println(month_list);\r\n\t}\r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"asList\"<\/a><\/p>\n
The above program demonstrates the usage of the \u2018asList\u2019 method of Arrays class. Here, we have declared a string array and passed it to asList method to obtain a list.<\/p>\n
#2) binarySearch<\/span><\/h3>\n
Prototype: <\/strong>static int binarySearch (int[] a, int key)<\/p>\n
Parameters:<\/strong><\/p>\n
a => array in which the key is to be searched
\nKey=> element value to be searched<\/p>\n
Return Value: <\/strong>int=>position (index) at which key is found, else returns (-(the “insertion point”) – 1).<\/p>\n
Description: <\/strong>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.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays;\r\nimport java.util.List;\r\n\r\npublic class Main { \r\n    public static void main(String[] args) \r\n    { \r\n        \/\/ define the Array \r\n        int numArr[] = { 23,43,26,65,35,16,74,27,98 }; \r\n        \/\/sort the array first\r\n        Arrays.sort(numArr); \r\n        System.out.println("Input array:" + Arrays.toString(numArr));\r\n\r\n         int key = 35; \r\n        \/\/call binarySearch function to search a given key\r\n         System.out.println("Key " + key + " found at index = " + Arrays \r\n                                 .binarySearch(numArr, key)); \r\n    } \r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"binarySearch\"<\/a><\/p>\n
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 \u2018binarySearch\u2019 method. The index at which the key is found is displayed in the output.<\/p>\n
Prototype: <\/strong>static int binarySearch (int[] a, int fromIndex, int toIndex, int key)<\/p>\n
Parameters: <\/strong><\/p>\n
a=> array to be searched
\nfromIndex=> starting index of the range over which the key is to be searched
\ntoIndex=> the index of the last element in the range
\nkey=> key to be searched for<\/p>\n
Return Value: <\/strong>index of the key element is found in the specified range. Otherwise it returns (-(the “insertion point”) – 1).<\/p>\n
Description: <\/strong>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\u2019s not sorted, then the results are undefined.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays;\r\nimport java.util.List;\r\n\r\npublic class Main {\r\n    public static void main(String[] args)\r\n    {\r\n      int numArr[] = { 23,43,26,65,35,16,74,27,98 }; \/\/ define the Array\r\n      Arrays.sort(numArr); \/\/sort the array first\r\n      System.out.println("Input array:" + Arrays.toString(numArr));\r\n      int key = 35;\r\n      \/\/call binarySearch function to search a given key\r\n      System.out.println("Key " + key + " found at index = " + Arrays\r\n                 .binarySearch(numArr,3,7, key));\r\n     }\r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"Returns<\/a><\/p>\n
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.<\/p>\n
#3) copyOf<\/span><\/h3>\n
Prototype: <\/strong>static int[] copyOf(int[] original, int newLength)<\/p>\n
Parameters: <\/strong><\/p>\n
original=> array to be copied
\nnewLength=> length of the copied array<\/p>\n
Return Value: <\/strong>A new array copied from the original and padded or truncated with zeros depending on a specified length.<\/p>\n
Description: <\/strong>Copies the array original into a new array and pads or truncates it with zeros depending on the length specified.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main { \r\n    public static void main(String[] args) \r\n    { \r\n\r\n        \/\/ define the Array \r\n        String strArr[] = {"Java", "Python", "Perl", "C", "Ruby"}; \r\n\r\n        \/\/ print the original array \r\n       System.out.println("Original String Array: "\r\n                           + Arrays.toString(strArr)); \r\n        \/\/copy the array into new array using copyOf and print it\r\n        System.out.println("Copied Array: "\r\n                           + Arrays.toString(\r\n                      Arrays.copyOf(strArr, 5))); \r\n    } \r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"copyOf\"<\/a><\/p>\n
The above program demonstrates the use of the \u2018copyOf\u2019 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.<\/p>\n
#4) copyOfRange<\/span><\/h3>\n
Prototype: <\/strong>static int[] copyOfRange(int[] original, int from, int to)<\/p>\n
Parameters:<\/strong><\/p>\n
original => array from which values in the range are to be copied
\nFrom=> first index of the range
\nTo=> last index of the range<\/p>\n
Return Value:<\/strong> New array with values from the specified range with zeros truncated or padded to obtain the desired length.<\/p>\n
Description: <\/strong>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.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main { \r\npublic static void main(String[] args) \r\n    { \r\n         \/\/ define the Array \r\n        String strArr[] = {"Java", "Python", "Perl", "C", "Ruby"}; \r\n\r\n        \/\/ print the original array \r\n       System.out.println("Original String Array: "  + Arrays.toString(strArr)); \r\n        \/\/copy the array into new array using copyOfRange and print it\r\n       System.out.println("Copied Range of Array: "\r\n                  + Arrays.toString(\r\n                         Arrays.copyOfRange(strArr,1,3))); \r\n    } \r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"copyOfRange\"<\/a><\/p>\n
We have modified the previous program to use the \u2018copyOfRange\u2019 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.<\/p>\n
#5) Equals<\/span><\/h3>\n
Prototype: <\/strong>static boolean equals (int [] a, int [] a2)<\/p>\n
Parameters: <\/strong><\/p>\n
a=> <\/em><\/strong>first array to be tested for equality
\nA2=> second array to be tested for equality<\/p>\n
Return Value: <\/strong>Returns true if both arrays are equal.<\/p>\n
Description: <\/strong>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.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/ define two arrays, array_One and array_Two\r\n\t\tint[] array_One = { 1, 3, 5, 7 };\r\n\t\tint[] array_Two = { 1, 3, 5, 7 };\r\n\t\t\/\/print the arrays\r\n\t\tSystem.out.println("array_One = " + Arrays.toString(array_One));\r\n\t\tSystem.out.println("array_Two = " + Arrays.toString(array_Two));\r\n\t\t\/\/use equals method to check for equality of arrays\t\t\r\n\t\tbooleanarray_equal = Arrays.equals(array_One, array_Two);\r\n\t\t\/\/print the results\r\n\t\tif (array_equal) {\r\n\t\t\tSystem.out.println("equals method returns " + array_equal + \r\n\t\t\t", hence arrays array_One and array_Two are equal\\n");\t\r\n\t\t}else {\r\n\t\t\tSystem.out.println("equals method returns " + array_equal + \r\n\t\t\t", hence arrays array_One and array_Two are not equal\\n");\r\n\t\t}\r\n\t\t\/\/ define two more arrays, firstArray&amp;secondArray\r\n\t\tint[] firstArray = { 2, 4, 6, 8 };\r\n\t\tint[] secondArray = { 1, 3, 5, 7};\r\n\t\t \/\/display these arrays\r\n\t\tSystem.out.println("firstArray = " + Arrays.toString(firstArray));\r\n\t\tSystem.out.println("secondArray = " + Arrays.toString(secondArray));\r\n\t\t\/\/use equals method to check equality of arrays\t\t\r\n\t\tboolean test_array = Arrays.equals(firstArray, secondArray);\r\n\t\t\r\n\t\t\/\/print the results\r\n\t\tif (test_array) {\r\n\t\t\tSystem.out.println("equals method returns " + test_array + \r\n\t\t\t", hence arrays firstArray and secondArray are equal\\n");\t\r\n\r\n\t\t}else {\r\n\t\t\tSystem.out.println("equals method returns " + test_array + \r\n\t\t\t", hence arrays firstArray and secondArray are not equal\\n");\r\n\t\t}\r\n\t}\r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"Equals\"<\/a><\/p>\n
The above program demonstrates the \u2018equals\u2019 method. Here, we have used two sets of arrays and called \u2018equals\u2019 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.<\/p>\n
#6) Fill<\/span><\/h3>\n
Prototype:<\/strong> static void fill(int[] a, int val)<\/p>\n
Parameters: <\/strong><\/p>\n
a=> array to be filled
\nval=> value to be filled in all places in array<\/p>\n
Return Value: <\/strong>None
\nDescription: <\/strong>Fills the array with the specified value.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/ define the array\r\n\t\tint[] intArray = { 1, 3, 5, 7 };\r\n\t\t\/\/print original array\r\n\t\tSystem.out.println("The original array: " + Arrays.toString(intArray));\r\n\t\t\/\/call fill method to fill the array with all zeros\t\t\r\n\t\tArrays.fill(intArray, 0);\r\n\t\t\/\/print altered array\r\n\t\tSystem.out.println("Array after call to fill:" + Arrays.toString(intArray));\r\n\t}\t\t\r\n}\r\n<\/pre>\n
Output:<\/strong><\/p>\n
\"Fill\"<\/a><\/p>\n
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.<\/p>\n
Prototype: <\/strong>static void fill(int[] a, int fromIndex, int toIndex, int val)<\/p>\n
Parameters: <\/strong><\/p>\n
a=> array whose range is to be filled
\nfromIndex => start index of the range
\ntoIndex => end index of the range
\nval=> value with which the elements in the range is to be filled<\/p>\n
Return Value: <\/strong>None<\/p>\n
Description: <\/strong>Fills the specified range from fromIndex to toIndex in the array \u2018a\u2019 with the specified value. If fromIndex = toIndex, then the range to be filled is empty.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/ define the array\r\n\t\tint[] intArray = { 1, 3, 5, 7, 9, 11, 13, 15,17};\r\n\t\t\/\/print original array\r\n\t\tSystem.out.println("The original array: " + Arrays.toString(intArray));\r\n\t\t\/\/call fill method to fill the range (2,6) in the array with zeros\t\t\r\n\t\tArrays.fill(intArray, 2, 6, 0);\r\n\t\t\/\/print altered array\r\n\t\tSystem.out.println("Array after call to fill the range(2,6):" + Arrays.toString(intArray));\r\n\t}\t\t\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
\"Fills<\/a><\/p>\n
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.<\/p>\n
#7) Sort<\/span><\/h3>\n
Prototype:<\/strong> static void sort(int[] a)
\nParameters: <\/strong>a=> array to be sorted
\nReturn Value: <\/strong>None
\nDescription: <\/strong>This method sorts the array in ascending order.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/ define the array\r\n\t\tint[] intArray = {10,4,25,63,21,51,73,24,87,18};\r\n\t\t\/\/print original array\r\n\t\tSystem.out.println("The original array: " + Arrays.toString(intArray));\r\n\t\t\/\/call sort method to sort the given array in ascending order\t\t\r\n\t\tArrays.sort(intArray);\r\n\t\t\/\/print altered array\r\n\t\tSystem.out.println("Sorted array:" + Arrays.toString(intArray));\r\n\t}\t\t\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
\"Sort\"<\/a><\/p>\n
The above program sorts an array of integers using the sort method of Arrays class and prints the sorted array.<\/p>\n
Prototype: <\/strong>static void sort(int[] a, int fromIndex, int toIndex)<\/p>\n
Parameters:<\/strong><\/p>\n
a=> array from which a range is to be sorted
\nfromIndex => start index for the range
\ntoIndex=> end index for the range<\/p>\n
Return Value: <\/strong>none<\/p>\n
Description: <\/strong>Sorts the range specified from fromIndex to toIndex in ascending order. If fromIndex=toIndex, then range to be sorted is empty.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.Arrays; \r\n\r\npublic class Main {\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/ define the array\r\n\t\tint[] intArray = {10,4,25,63,21,51,73,24,87,18};\r\n\t\t\/\/print original array\r\n\t\tSystem.out.println("The original array: " + Arrays.toString(intArray));\r\n\t\t\/\/call sort method to sort the given range in the array in ascending order\t\t\r\n\t\tArrays.sort(intArray, 2, 7);\r\n\t\t\/\/print altered array\r\n\t\tSystem.out.println("Sorted range(2,7) in the array:" + Arrays.toString(intArray));\r\n\t}\t\t\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
\"Sorts<\/a><\/p>\n
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.<\/p>\n
Hence in the output, we can see that only the elements in this range are sorted in ascending order.<\/p>\n
#8) toString<\/span><\/h3>\n
Prototype: <\/strong>static String toString(int[] a)
\nParameters: <\/strong>a=> array whose string representation is required
\nReturn Value: <\/strong>string=> string representation of array
\nDescription: <\/strong>Converts the given array into its string representation.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.*;\r\n\r\npublic class Main\r\n{\r\n\tpublic static void main(String[] args) {\r\n\t\t\/\/declare arrays of type int and double\r\n\t\tint[] intArray = {10,20,30,40,50};\r\n\t\t\r\n\t\tdouble[] dblArray = {1.0,2.0,3.0,4.0,5.0};\r\n\t\t\r\n\t\tSystem.out.println("String representation of int Array: ");\r\n\t\t\/\/print string representation of int array using toString\r\n\t\tSystem.out.println(Arrays.toString(intArray));\r\n\t\t\r\n\t\tSystem.out.println("\\nString representation of double Array: ");\r\n\t\t \/\/print string representation of double array using toString\t\r\n\t\tSystem.out.println(Arrays.toString(dblArray));\r\n\t}\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
\"toString\"<\/a><\/p>\n
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.<\/p>\n
#9) hashCode<\/span><\/h3>\n
Prototype:<\/strong> static int hashCode(int[] a)
\nParameters: <\/strong>a=> array whose hashcode is to be computed.
\nReturn Value: <\/strong>int=> hashcode computed<\/p>\n
Description: <\/strong>The method returns the hashcode of a given array. The hashcode<\/strong>\u00a0of a\u00a0Java<\/strong> Object is actually a 32-bit number (signed int). Using hashcode you can manage an object using hash-based structure.<\/p>\n
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.<\/p>\n
Example:<\/strong><\/span><\/p>\n
\r\nimport java.util.*;\r\n\r\npublic class Main\r\n{\r\n\tpublic static void main(String[] args) {\r\n\t\t\r\n\t\t\/\/declare arrays of type int\r\n\t\tint[] intArray = {10,20,30,40,50};\r\n\t\t\/\/print the input array\r\n\t\tSystem.out.println("The input Array: " + Arrays.toString(intArray));\r\n\t\t\/\/get hashcode of the array using 'hashCode' method of array\r\n\t\tinthashCde = Arrays.hashCode(intArray);\r\n\t\t\/\/print the hashCode\t\r\n\t\tSystem.out.println("The hashCode for input array:" + hashCde);\r\n\t}\r\n}<\/pre>\n
Output:<\/strong><\/p>\n
\"hashCode\"<\/a><\/p>\n
The hashCode method computes the hashcode for the given array passed as an argument to it.<\/p>\n
Frequently Asked Questions<\/h3>\n
Q #1) What are java.util arrays?<\/span><\/strong><\/p>\n
Answer:<\/strong> 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.<\/p>\n
Q #2) Which sorting is used in arrays sort in Java?<\/span><\/strong><\/p>\n
Answer:<\/strong> 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.<\/p>\n
Q #3) What does Arrays.sort () method do in Java?<\/span><\/strong><\/p>\n
Answer:<\/strong> 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\u2019s arrays.<\/p>\n
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.<\/p>\n
Q #4) What are collections and arrays class?<\/span><\/strong><\/p>\n
Answer:<\/strong> 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.<\/p>\n
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.<\/p>\n
Conclusion<\/h2>\n
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.<\/p>\n
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.<\/p>\n
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.<\/p>\n
=> Visit Here To Learn Java From Scratch.<\/a><\/strong><\/p>\n\r\n\t\t\t
\r\n\r\n\t\t\t\t
\r\n\t\t\t\t\t
\r\n\t\t\t\t\t\t
Was this helpful?<\/h3>\r\n\t\t\t\t\t<\/div>\r\n\t\t\t\t\t
\r\n\t\t\t\t\t\t
\r\n\t\t\t\t\t\t\t\r\n\t\t\t
\r\n\t\t\t\t\r\n                \r\n                    \r\n                        
\r\n\t\t\t\t\r\n                \r\n                    \r\n                        
\r\n\t\t\t\t\t
\r\n\t\t\t\t\t\t