Array is used to store same ‘type’ of data that can be logically
grouped together. Array is a fundamental construct in any programming
languages. This Java tutorial is planned to provide comprehensive
information about Java arrays.
Array is one among the many beautiful things in a programming
language. Easy to iterate, easy to store and retrieve using their index.
In Java, a beginner starts with
public static void main(String args[]). The argument for the main method is an array. We encounter arrays early on.
Java Arrays
In java arrays are objects. All methods of an Object can be invoked on an array. Arrays are stored in
heap memory.
Logical view of an Array
Though we view the array as cells of values, internally they are
cells of variables. A java array is a group of variables referenced by a
common name. Those variables are just references to a
address and
will not have a name. These are called the ‘components’ of a java
array. All the components must be of same type and that is called as
‘component type’ of that java array.
Physical view of an Array
Array Declaration
int []marks;
or
int marks[];
Array Instantiation
marks = new int[5];
5 inside the square bracket says that you are going to store five
values and is the size of the array ‘n’. When you refer the array
values, the index starts from 0 ‘zero’ to ‘n-1’. An array index is
always a whole number and it can be a int, short, byte, or char.
Once an array is instantiated, it size cannot be changed. Its size can be accessed by using the length field like .length Its a
java final instance field.
All java arrays implements
Cloneable and
Serializable.
Java array initialization and instantiation together
int marks[] = {98, 95, 91, 93, 97};
ArrayIndexOutOfBoundsException
One popular
exception
for java beginners is ArrayIndexOutOfBoundsException. You get
ArrayIndexOutOfBoundsException when you access an array with an illegal
index, that is with a negative number or with a number greater than or
equal to its size. This stands second next to
NullPointerException in java for popularity.
Java Array Default Values
After you instantiate an array, default values are automatically assigned to it in the following manner.
- byte – default value is zero
- short – default value is zero
- int – default value is zero
- long – default value is zero, 0L.
- float – default value is zero, 0.0f.
- double – default value is zero, 0.0d.
- char – default value is null, ‘\u0000’.
- boolean – default value is false.
- reference types – default value is null.
Notice in the above list, the
primitives and reference types are treated differently. One popular cause of
NullPointerException is accessing a null from a java array.
Iterating a Java Array
public class IterateJavaArray {
public static void main(String args[]) {
int marks[] = {98, 95, 91, 93, 97};
//java array iteration using enhanced for loop
for (int value : marks){
System.out.println(value);
}
}
}
In language C, array of characters is a String but this is not the
case in java arrays. But the same behaviour is implemented as a
StringBuffer wherein the contents are mutable.
ArrayStoreException – When you try to store a non-compatible value in a java array you get a ArrayStoreException.
Multidimensional Arrays
When a component type itself is a array type, then it is a
multidimensional array. Though you can have multiple dimension nested to
n level, the final dimension should be a basic type of
primitive or an Object.
int[] marks, fruits, matrix[];
In the above code, matrix is a multidimensional array. You have to be careful in this type of java array declaration.
Internally multidimensional java arrays are treated as arrays of
arrays. Rows and columns in multidimensional java array are completely
logical and depends on the way you interpret it.
Note: A clone of a java multidimensional array will result in a
shallow copy.
Iterate a java multidimensional array
Following example source code illustrates on how to assign values and iterate a multidimensional java array.
public class IterateMultiDimensionalJavaArray {
public static void main(String args[]) {
int sudoku[][] = { { 2, 1, 3 }, { 1, 3, 2 }, { 3, 2, 1 } };
for (int row = 0; row < sudoku.length; row++) {
for (int col = 0; col < sudoku[row].length; col++) {
int value = sudoku[row][col];
System.out.print(value);
}
System.out.println();
}
}
}
Sort a Java array
java api Arrays contains static methods for sorting. It is a best practice to use them always to sort an array.
import java.util.Arrays;
public class ArraySort {
public static void main(String args[]) {
int marks[] = { 98, 95, 91, 93, 97 };
System.out.println("Before sorting: " + Arrays.toString(marks));
Arrays.sort(marks);
System.out.println("After sorting: " + Arrays.toString(marks));
}
}
//Before sorting: [98, 95, 91, 93, 97]
//After sorting: [91, 93, 95, 97, 98]
Copy a Java array
You can use the following options to copy a java array:
- As illustrated above you can use the util calls Arrays. It contains copyOf method for different java types.
- The most used class by a java beginner 'System' has a static method to copy an array.
- Using its clone method you can copy a java array. If the java array is multidimensional, it will be a shallow copy.
- Write your own for loop iterating through the java array and copy elements yourself. (least preferred)
SOURCE 
