The need for an Array<\/h3>\n
Arrays are very useful in cases where many elements of the same data types need to be stored and processed. It is also useful in real-time projects to collect the same type of objects and send all the values with a single method call.<\/p>\n
Types of Java Arrays<\/h3>\n
1. Single dimensional arrays\/one-dimensional array<\/strong> – comprised of finite homogeneous elements.<\/p>\n 2. Multi-dimensional arrays<\/strong> – comprised of elements, each of which is itself an array.<\/p>\n The simplest of multidimensional arrays is a two-dimensional array. However, Java allows arrays of more than two dimensions. The compiler you use can determine the exact limit of dimensions.<\/p>\n We will discuss in detail about single-dimensional and two-dimensional arrays:<\/p>\n The simplest form of an array is a single-dimensional array. It has elements in a single dimension. Such as a variable, method, and class, we can give a name to the array. And, we refer to array elements by their subscripts or indices.<\/p>\n Like other definitions, an array definition specifies a variable type and a name along with one more feature size to specify how many items the array will contain.<\/p>\n The valid syntax for array declaration can be –<\/strong><\/p>\n Example –<\/strong><\/p>\n After declaring an array, we allocate the memory to the array with the help of a new operator and assign the memory to the array variable. So, let us see how we can initialize arrays in different ways. The variable size of the array should be of constant integer type without any sign (+ or -).<\/p>\n The valid syntax for array initialization can be –<\/strong><\/p>\n Example –<\/strong><\/p>\n We can also combine declaration and initialization and write as follows:<\/p>\n Note<\/strong> – Java stores the value of each element with 0 if the elements of an array are not given.<\/em><\/p>\n The below diagram shows the illustration of one-dimensional arrays.<\/p>\n An array element may be accessed or used in a place where an ordinary variable of the same type may be used. An array element is addressed or referred using the array name followed by an integer subscript or index in square brackets[ ].<\/p>\n For example, myArray[2]; will give us the third element of the array myArray.<\/p>\n We can access each element of the array using Java for<\/strong> loop.<\/p>\n For example:<\/strong><\/p>\n Code Snippet to illustrate declaring, initializing, and accessing array:<\/strong><\/p>\n Output:<\/strong><\/p>\n We can also access or use the elements of Java array using a for-each<\/strong> loop. The for-each loop in Java is used to print the array elements one after the other. It holds an array element in a variable and then executes the loop body.<\/p>\n The syntax of the for-each loop is:<\/strong><\/p>\n Code Snippet to access an array using a for-each loop:<\/strong><\/p>\n Output:<\/strong><\/p>\n We can also pass the Java array to methods or functions, just like normal variables. Passing an array to method helps us to reuse the same logic on any array.<\/p>\n When we pass an array as an argument to a method, it is actually the address of the first element of the array (base address) which is passed as a reference. Therefore, if we make any changes to this array in the method, it will affect the array.<\/p>\n Syntax:<\/strong><\/p>\n When we pass an array to a method, we specify the name of the array without any square brackets within the method call.<\/p>\n Code to illustrate the passing of an array to a method:<\/strong><\/p>\n Output:<\/strong><\/p>\n Arrays are the object of a class, and the class \u2018Object\u2019<\/strong> is the direct superclass of arrays. The members of an array are:<\/p>\n Single-dimensional arrays are lists of data of the same type and their elements are stored in a contiguous memory location in their index order. For instance, an array age of type int with 5 elements is declared as:<\/p>\n int age[ ] = new int[5 ];<\/p>\n Or as,<\/p>\n int[ ] age = new int[5 ];<\/p>\n This array will have age[0] at the first allocated memory location, age[1] at the next memory location and so on. Since age is an int type array, the size of each element is 4 bytes. If the starting memory location of array age is 5000, then it will be represented in the memory location as follows:<\/p>\n We can address or refer to each element of the array using the name of the array with subscripts or indexes 0, 1, 2\u2026.., size-1, where size is the total number of elements of the array. That is if an array is arr[6], then legal array elements would be:<\/p>\n arr[0] , arr[1], arr[2], arr[3], arr[4], arr[5]<\/p>\n Subscripts or index which are less than zero or greater than or equal (>=) to a number of elements are illegal since they do not correspond to real memory locations in the array. For example, the following are some illegal subscripts for above-mentioned array (that is, all other than legal subscripts):<\/p>\n arr[-5], arr[-1], arr[8], arr[7] etc.<\/p>\n These subscripts are said to be out-of-bounds<\/strong>. Reference to an out-of-bounds indexing produces an out-of-bounds exception<\/strong>, and the program will crash if the exception is not handled.<\/p>\n Note:<\/strong> The subscripts other than 0\u2026..n-1 (both inclusive limits) for an array having n elements, are called out-of-bound subscripts.<\/em><\/p>\n Code to understand OutOfBoundsException:<\/strong><\/p>\n Output:<\/strong><\/p>\n Till now, we have worked on arrays with a single dimension. Now we will move to the concept of multi-dimensional arrays that have multiple or more than one dimension.<\/p>\n Multi-dimensional arrays are arrays of arrays<\/strong> in which each element of the array holds the reference of other arrays. We can also call them Jagged Arrays. The most commonly used multi-dimensional array is a two-dimensional array.<\/strong><\/p>\n A two-dimensional<\/strong> array is an array in which each element is a one-dimensional array.<\/p>\n For example, a two-dimensional array myArray [ M ]<\/strong>[ N ] is an M by N table with M rows and N columns containing M N elements.<\/strong><\/p>\n By multiplying the number of rows with the number of columns we can determine the number of elements in a two-dimensional array. For example, the number of elements in an array arr [7][9] is calculated as 7 9 = 63.<\/p>\n Following diagram illustrates a multi-dimensional array:<\/p>\n Syntax of declaring two-dimensional arrays is:<\/strong><\/p>\n or,<\/p>\n Example:<\/strong><\/p>\n or,<\/p>\n The array myArray<\/strong> has 5 elements myArray [0], myArray[1], myArray[3], and myArray[4], each of which itself is an int<\/strong> array with 12 elements<\/strong>.<\/p>\n The elements of myArray can be referred to as myArray[0][0], myArray[0][1], myArray[0][2],\u2026\u2026.., myArray[0][12], myArray [1][0], ……. and so forth.<\/p>\n Code to understand two-dimensional arrays:<\/strong><\/p>\n Output:<\/strong><\/p>\n There are 2 different types of cloning of arrays, they are as follows –<\/p>\n Cloning a single-dimensional array, such as Object[ ], means performing a \u201cdeep copy\u201d operation in which a new array is created, which contains copies of the elements of the original arrays. We can perform cloning of arrays in Java with the help of the clone()<\/strong> method:<\/p>\n Cloning is necessary when we want to create an object with a similar state as the original object. In short, with the help of Cloning single-dimension, we can create the copy of the original object.<\/p>\n Code to illustrate cloning of one-dimensional arrays:<\/strong><\/p>\n Output:<\/strong><\/p>\n Cloning a multi-dimensional array, such as Object[ ][ ], means performing a \u201cshallow copy\u201d. It creates only a single new array with each element of the array as a reference to an element of the original array.<\/p>\n In the cloning of multi-dimensional arrays, subarrays are shared, that is, they are not cloned.<\/p>\n Code to illustrate cloning of multi-dimensional arrays:<\/strong><\/p>\n Output:<\/strong><\/p>\n1. Single Dimensional Arrays<\/span><\/h4>\n
1.1. Declaring one-dimensional arrays<\/h5>\n
data-type array_name [ ];\ndata-type [ ] array_name;<\/pre>\n
int daysInMonth [ ];\nchar [ ] lettersInSentence;\ndouble salaryOfEmployees [ ];\nString progLanguages[ ];<\/pre>\n
1.2. Initializing one-dimensional arrays<\/h5>\n
array_name = new data-type [size of array];\narray_name = new data-type {elements of array using commas};<\/pre>\ndaysInMonth = new int [100];\nlettersInSentence = new char[5];\nsalaryOfEmployees = new double[ ] {10000, 50000, 30000, 25000 };\nprogLanguages = { \u201cC\u201d, \u201cJava\u201d, \u201cRuby\u201d, \u201cPython\u201d, \u201cPHP\u201d };<\/pre>\nint daysInMonth[ ] = new int [100];\nchar [ ] lettersInSentence = new char[5];<\/pre>\n
![\"one](\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/sites\/2\/2020\/02\/one-dimensional-array-in-java.jpg\")
<\/a><\/p>\n1.3. Accessing or using one-dimensional arrays<\/h5>\n
\/\/ accessing all elements of the specified array\nfor (int i = 0; i < myArray.length; i++)\n System.out.println(\"Element at index \" + i + \" : \"+ myArray[ i ]);<\/pre>\n
package com.TechVidvan.JavaArrays;\npublic class OneDimesionalArray\n{\n \/\/ Java program to illustrate store and print marks of 5 students\n public static void main (String[] args)\n {\n \/\/ declaring an Array of integers.\n int[] marks;\n\n \/\/ allocating memory for 5 integers.\n marks = new int[5];\n \n \/\/ initializing the first element of the array\n marks[0] = 78;\n \/\/ initializing the second element of the array and so on..\n marks[1] = 85;\n marks[2] = 97;\n marks[3] = 66;\n marks[4] = 70;\n\n \/\/ accessing the elements of the specified array\n for (int iterator = 0; iterator < marks.length; iterator++)\n System.out.println(\"Marks of Student \" + (iterator+1) +\": \"+ marks[iterator]);\n }\n}<\/pre>\n
\nMarks of Student 2: 85
\nMarks of Student 3: 97
\nMarks of Student 4: 66
\nMarks of Student 5: 70<\/div>\nfor(data_type variable:array)\n{\n \/\/body of the loop\n}<\/pre>\npackage com.techvidvan.javaarrays;\npublic class OneDimesionalArray\n{\n public static void main (String[] args)\n {\n \/\/ declaring an Array of integers.\n int[] marks = new int[5];\n \/\/ initialize elements of the array\n marks[0] = 78;\n marks[1] = 85;\n marks[2] = 97;\n marks[3] = 66;\n marks[4] = 70;\n\n \/\/ accessing the elements of the specified array\n System.out.println(\"Marks of 5 Students:\");\n for (int iterator :marks)\n System.out.println(iterator);\n }\n}<\/pre>\n
\n78
\n85
\n97
\n66
\n70<\/div>\nPassing an Array to a method or function<\/h5>\n
int[] num = new int[10]; \t\/\/array declaration\nmethodName (int [] x) \t\t\/\/passing an array to method\n{\n \/\/method body\n}\nmethodName (num); \t\t\t\/\/calling the method<\/pre>\npackage package com.techvidvan.javaarrays;;\npublic class PassingArrayToMethod\n{\n public static void main (String[] args)\n {\n int myArray[] = { 1, 2, 3, 4, 5, 6 }; \/\/creating array\n System.out.println(\"Array before passing to a method:\");\n {\n for(int i=0; i<myArray.length;i++)\n {\n System.out.println(myArray[i]);\n }\n }\n System.out.println(\"Array after passing to a method:\");\n \/\/calling method by passing myArray to them.\n manipulateArray(myArray);\n display(myArray);\n } \/\/main method ends here\n static void manipulateArray(int a[]) \/\/declaring method\n {\n for(int i=0; i<a.length;i++)\n {\n a[i] = a[i]*10;\n }\n }\n static void display(int a[]) \/\/declaring method\n {\n System.out.println(\"Displaying array elements after \t\t\t\t\tmultiplying each element by 10:\");\n for(int i=0; i<a.length;i++)\n {\n System.out.println( a[i] );\n }\n }\n}<\/pre>\n
\n1
\n2
\n3
\n4
\n5
\n6
\nArray after passing to a method:
\nDisplaying array elements after multiplying each element by 10:
\n10
\n20
\n30
\n40
\n50
\n60<\/div>\nArray Members<\/h3>\n
\n
1.4. Memory Representation of single-dimensional arrays<\/h4>\n
<\/a><\/strong><\/p>\nArrayIndexOutOFBoundExceptions<\/h3>\n
package package com.techvidvan.javaarrays;;\npublic class OneDimesionalArray\n{\n public static void main (String[] args)\n {\n int[] arr = new int[5];\n arr[0] = 10;\n arr[1] = 20;\n arr[2] = 10;\n arr[3] = 20;\n arr[4] = 10;\n \/\/ trying to access arr[5] will give an exception\n for (int i = 0; i <= 5; i++)\n System.out.println(arr[i]);\n }\n}<\/pre>\n
\n20
\n10
\n20
\n10
\nException in thread “main” java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
\nat project1\/package com.techvidvan.javaarrays;.OneDimesionalArray.main(OneDimesionalArray.java:19)<\/div>\nMulti-Dimensional Arrays<\/h3>\n
<\/a><\/p>\ntype array-name [ ][ ]= new type[number of rows] [number of columns];<\/pre>\n
type [ ][ ] array-name = new type[number of rows] [number of columns];<\/pre>\n
int myArray [ ] [ ] = new int [5] [12] ;<\/pre>\n
int[ ] [ ] myArray = new int[5] [12] ;<\/pre>\n
package package com.techvidvan.javaarrays;\npublic class TwoDimensionalArrays\n{\n public static void main (String[] args)\n {\n \/\/declaring and initializing a two-dimensional array\n int[][] myArray = new int[3][3];\n\n myArray[0][0]=1;\n myArray[0][1]=2;\n myArray[0][2]=3;\n myArray[1][0]=4;\n myArray[1][1]=5;\n myArray[1][2]=6;\n myArray[2][0]=7;\n myArray[2][1]=8;\n myArray[2][2]=9;\n\n \/\/printing a two-dimensional array\n for(int i=0;i<3;i++)\n {\n for(int j=0;j<3;j++)\n {\n System.out.print(myArray[i][j]+\" \");\n }\n System.out.println();\n }\n }\n}<\/pre>\n
\n4 5 6
\n7 8 9<\/div>\nCloning of arrays<\/h3>\n
1. Cloning single-dimensional arrays<\/h4>\n
package com.techvidvan.javaarrays;\nimport java.util.Arrays;\npublic class Cloning\n{\n public static void main(String[] args)\n {\n int intArray[] = { 50, 60, 70 };\n int clonedArray[] = intArray.clone();\n\n \/\/ will print false as a deep copy is created for a one-dimensional array\n System.out.println(intArray == clonedArray);\n\n System.out.print(\"Printing cloned array:\\n\");\n for (int i = 0; i < clonedArray.length; i++)\n {\n System.out.print(clonedArray[i]+\" \");\n }\n }\n}<\/pre>\n
\nPrinting cloned array:
\n50 60 70<\/div>\n<\/a><\/p>\n2. Cloning of multi-dimensional arrays<\/h4>\n
package com.techvidvan.javaarrays;\nimport java.util.Arrays;\npublic class Cloning\n{\n public static void main(String[] args)\n {\n int intArray[][] = {{1,2,3},{4,5,6}};\n int clonedArray[][] = intArray.clone();\n\n \/\/ will print false\n System.out.println(intArray == clonedArray);\n\n \/\/ it will print true as a shallow copy is created and sub-arrays are \/\/shared\n System.out.println(intArray[0] == clonedArray[0]);\n System.out.println(intArray[1] == clonedArray[1]);\n\n System.out.println(\"\\nPrinting cloned array:\");\n for (int i = 0; i < 2; i++)\n {\n for (int j = 0; j < 3; j++)\n {\n System.out.print(clonedArray[i][j]+ \" \");\n }\n System.out.println();\n }\n }\n}<\/pre>\n
\ntrue
\ntrue
\nPrinting cloned array:
\n1 2 3
\n4 5 6<\/div>\n