Java Arrays

Array is collection of similar type of elements in java programming. Each array are allocate memory on a heap area and array variable are store the reference of created array. Size of array is based on number of elements in array. When initial not provide array elements then size are compulsory.

Java array declaration

Array is declare in following ways in java programming.

//Both declaration of array are similar 
String name[]; 
String []myName;

That is similar to define a normal variable, But there are only difference is that are used pair of ([]) square brackets after the data type.

In above example both arrays declaration are valid and similar. We can choose to anyone of this method. When we declare an array that means we can define the behaviour of array like which type of data it will store during program execution and what is the name of this array identifier. For example.

// Example of array declaration in Java
class MyArrays
{
    public static void main(String[] args)
    {
        int[] intArrayElement; // array of integer elements
        byte[] byteArrayElement; // array of byte elements
        short[] shortsArrayElement; // array of short data elements
        boolean[] booleanArrayElement; // array of boolean data elements
        long[] longArrayElement; // array of long data elements
        float[] floatArrayElement; // array of float data elements
        double[] doubleArrayElement; // array of double data elements
        char[] charArrayElement; // array of char data elements
        // special case when create array of object
        MyArrays[] obj; // Array of object element
    }
}

Note that there is not possible to declare two same variable name of array in same scope. And All java array is dynamic allocated. And array are capable to store primitive data type value and object of class type. there is depend upon which type of array are declare.

Initialization of array element

In previous section we are declaring arrays. In this case compiler are know about that what type of value are storing by particular array. But there are not creating actual physical memory to array. In this section we are view example how to create dynamic memory to particular array variable and how to set initial value to variable. See this example.

class MyArrays
{
    public static void main(String[] args)
    {
        int[] intArrayElement; // Array of integer elements
        intArrayElement = new int[7]; // Allocate memory to variable
    }
}

In this example first is declared an integer array. After that allocated memory of this array by using of new operator. Note that new operator are create dynamic memory by using of data type and element size in array case.

Note that here is given two statement first declaring array and after that allocate memory to array variable. We can do this process by using single statement. See this example

// Create an array of 7 integer elements
int[] intArrayElement = new int[7];

That is a way to declare array of number of element. But we are know about initial value of array element then we can initialize element in this way.

class MyArrays
{
    public static void main(String[] args)
    {
        //Create an array of 7 integer elements
        int []intArrayElement = new int[]
        {
            1 , 2 , 3 , 4 , 5 , 6 , 7
        };
    }
}

In below image there are create created array are held the reference of new created array and array element are start with index zero and last element index are (elements-1).

create dynamic array in java

Memory are allocated array element always is contiguous manner. This reason that are we can get array element by its index value.

When we provide all initial element to array then we can remove new statement in array initialization. for this example.

class MyArrays
{
    public static void main(String[] args)
    {
        //Create array of string elements
        String []codeLanguage = {
            "C" , "C++" , "Java" , "C#" , "Kotlin" , "Swift"
        };
    }
}
static array declaration in java

Note that In this case compiler are decide the size of array by using of number of element in array. And size are cannot modified during program execution.

When we are declare an array elements and not set initial then compiler are provide default values to array elements.

public class DefaultArrayValue
{
    public static void main(String[] args)
    {
        // Declare array elements
        boolean[] myBoolElements = new boolean[3];
        int[] myIntElements = new int[2];
        float[] myFloatElements = new float[3];
        String[] myStringElements = new String[3];
        char[] myCharElements = new char[3];
        double[] myDoubleElements = new double[2];
        int index = 0;
        System.out.println("Default Value of Boolean Arrays elements");
        // Display Default value of array
        for (index = 0; index < myBoolElements.length; index++)
        {
            System.out.println(myBoolElements[index]);
        }
        System.out.println("Default Value of Integer Arrays elements");
        for (index = 0; index < myIntElements.length; index++)
        {
            System.out.println(myIntElements[index]);
        }
        System.out.println("Default Value of Float Arrays elements");
        for (index = 0; index < myFloatElements.length; index++)
        {
            System.out.println(myFloatElements[index]);
        }
        System.out.println("Default Value of String Arrays elements");
        for (index = 0; index < myStringElements.length; index++)
        {
            System.out.println(myStringElements[index]);
        }
        System.out.println("Default Value of char Arrays elements");
        for (index = 0; index < myCharElements.length; index++)
        {
            System.out.println(myCharElements[index]);
        }
        System.out.println("Default Value of Double Arrays elements");
        for (index = 0; index < myDoubleElements.length; index++)
        {
            System.out.println(myDoubleElements[index]);
        }
    }
}
Default values of array element in java

Note that default value of character are unicode '\u0000' value and that us print null character. The result of above program is produce following output.

Default Value of Boolean Arrays elements
false
false
false
Default Value of Integer Arrays elements
0
0
Default Value of Float Arrays elements
0.0
0.0
0.0
Default Value of String Arrays elements
null
null
null
Default Value of char Arrays elements



Default Value of Double Arrays elements
0.0
0.0

There are similar way we can create arrays of object in particular class. let see an example.

class Student
{
    int id;
    String name;
    Student(int id, String name)
    {
        this.id = id;
        this.name = name;
    }
    void displayRecord()
    {
        System.out.println("id : " + id);
        System.out.println("name : " + name);
    }
    public static void main(String[] args)
    {
        // Create array of objects
        Student[] record = new Student[5];
        for (int i = 0; i < record.length; i++)
        {
            // Set values of object
            record[i] = new Student(i + 1, "Foo" + (i + 1));
        }
        record[1].displayRecord(); // Display records  
    }
}
Create array of object in Java

Output

id : 2
name : Foo2

Update array elements

Get array element by index value, and similar way to modify of array element.

public class MyArrays
{
    // Display Array elements
    public static void dispaly(String[] arr)
    {
        for (String element: arr)
        {
            System.out.println(element);
        }
        System.out.println("------------");
    }
    public static void main(String[] args)
    {
        // Create array of string elements
        String[] code = {
            "C" , "C++" , "Java" , "C#" , "Kotlin" , "Swift"
        };
        System.out.println("Before Update");
        dispaly(code);
        // Update array element by index 
        code[2] = "Ruby";
        code[5] = "JavaScript";
        System.out.println("After Update");
        dispaly(code);
    }
}
Update array element in Java
Before Update
C
C++
Java
C#
Kotlin
Swift
------------
After Update
C
C++
Ruby
C#
Kotlin
JavaScript
------------

Element of array are mutable, It can be modified by specific array element index.

Multidimensional array

In this section we are view example how to implement multidimensional array in java programming. First view how to declare 2D array.

dataType [][] varName = new dataType[size][size];

See this are similar to one dimensional array only use one extra pair of ([]) square brackets in 2d array. See some examples.

//Create array of integers in 2 dimensional
//Size in form of 3 rows and 3 column
int [][] intData = new int[3][3]; 

//Create 2d String Array
//Size in form of 3 rows and 2 col
String[][] strData = new String[3][2];

//Create array of integers in 3 dimensional
//Size in form of (2 rows 3 column) * 3
float [][][] floatData = new float[2][3][2];  

Here created are 3 array of 2 different dimension. Square bracket is decide the dimension of array and each dimension are describe the capacity of array element.

First array in above example are 2 dimensional because they are declare by [][] double square bracket and there size are [3][3]. So this array are capable to store (3X3) 9 elements of integer type.

Second array is also an two dimensional, That are store the element of string type. The size of this array are [3][2] here 3 rows and 2 column. So this array are capable to store maximum (3*2) 6 elements.

Third array size are 3 dimensional and it can hold floating values (Depends upon defining data type). Let view implemented all three examples one by one.

Implement 2d arrays

// Example of 2d Array
class Multidimensional
{
    public static void main(String[] args)
    {
        // Create array of integers in 2 dimensional
        // Size in form of 3 rows and 3 column
        int[][] intData = new int[3][3];
        int data = 0;
        // Execute loop under the size of array                
        for (int row = 0; row < intData.length; row++)
        {
            // Execute loop under of rows column size
            for (int col = 0; col < intData[row].length; col++)
            {
                data++;
                // Set value
                intData[row][col] = data;
            }
        }
        // Execute loop under the size of array                
        for (int row = 0; row < intData.length; row++)
        {
            // Execute loop under of rows column size
            for (int col = 0; col < intData[row].length; col++)
            {
                // Display element values
                System.out.print(" " + intData[row][col]);
            }
            System.out.println(); // new line
        }
    }
}

Output

 1 2 3
 4 5 6
 7 8 9
Implement 2d array in java

Similar way we can create 3 dimensional array.

// Example of 3d Array
class Multidimensional
{
    public static void main(String[] args)
    {
        // Create array of integers in 3 dimensional
        // Size in form of (2 rows 3 column) * 3
        float[][][] floatData = new float[2][3][2];
        float data = 0.9 f;
        for (int dia = 0; dia < floatData.length; dia++)
        {
            // Execute loop under the size of array                
            for (int row = 0; row < floatData[dia].length; row++)
            {
                // Execute loop under of rows column size
                for (int col = 0; col < floatData[dia][row].length; col++)
                {
                    data++;
                    // Set value
                    floatData[dia][row][col] = data;
                }
            }
        }
        for (int dia = 0; dia < floatData.length; dia++)
        {
            // Execute loop under the size of array                
            for (int row = 0; row < floatData[dia].length; row++)
            {
                // Execute loop under of rows column size
                for (int col = 0; col < floatData[dia][row].length; col++)
                {
                    data++;
                    System.out.print(" " + floatData[dia][row][col]);
                }
                System.out.println();
            }
            System.out.println("");
        }
    }
}
Implement 3d array in java

Output

 1.9 2.9
 3.9 4.9
 5.9 6.9

 7.9 8.9
 9.9 10.9
 11.9 12.9

Jagged Array in Java

Jagged array is an array that are contains unknown number of column. That means initial are fixed that row size but not set number of column. See this example.

// Jagged Array
class Execution
{
    public static void main(String[] args)
    {
        // static initialize element 
        int[][] number = {
            {
                1
            },
            {
                1 , 2
            },
            {
                1 , 2 , 3
            },
            {
                1 , 2 , 3 , 4
            },
            {
                1 , 2 , 3 , 4 , 5
            },
            {
                7 , 8
            }
        };
        for (int rows[]: number)
        {
            for (int data: rows)
            {
                System.out.print(" " + data);
            }
            System.out.println();
        }
    }
}
Jagged Array in Java

Output

 1
 1 2
 1 2 3
 1 2 3 4
 1 2 3 4 5
 7 8

Observe that initially provided array element are not contains the column size are same.

Basic operation of array

Get the length of array

// Java program
// Get the size of array elements
class MyArray
{
    public static void main(String[] args)
    {
        int[] dataElement = {
            1 , 2 , 3 , 4 , 5 , 6 , 8
        };
        int size = dataElement.length;
        System.out.print("Size: " + size); //7
    }
}

Output

Size: 7

shuffle of array elements

// Implementing shuffle of array elements
import java.util.concurrent.ThreadLocalRandom;
class Execution
{
    // Implementing shuffle
    public void shuffleElement(int[] array)
    {
        for (int index = 1; index < array.length; index++)
        {
            // Generates the next pseudorandom number.
            int temp = ThreadLocalRandom.current().nextInt(index);
            // Swap array element by index value
            array[temp] += array[index];
            array[index] = array[temp] - array[index];
            array[temp] = array[temp] - array[index];
        }
    }
    // Display array element
    public void display(int[] array)
    {
        if (array.length == 0) return;
        System.out.print("Array Element :");
        for (int index = 0; index < array.length; index++)
        {
            System.out.print(" " + array[index]); // Display element
        }
        System.out.print("\n");
    }
    public static void main(String[] args)
    {
        Execution obj = new Execution();
        int[] myArray = {
            11 , 12 , 13 , 14 , 15 , 16 , 17 , 18 , 19 , 20
        };
        // Before
        System.out.println("Before shuffle array elements");
        obj.display(myArray);
        System.out.println("After shuffle array elements");
        // Shuffle array elements
        obj.shuffleElement(myArray);
        // After
        obj.display(myArray);
        System.out.println("Again of After shuffle array elements");
        // Shuffle array elements
        obj.shuffleElement(myArray);
        // After
        obj.display(myArray);
    }
}

Output

Before shuffle array elements
Array Element : 11 12 13 14 15 16 17 18 19 20
After shuffle array elements
Array Element : 13 19 20 17 12 15 16 11 18 14
Again of After shuffle array elements
Array Element : 19 16 15 14 11 18 17 13 12 20

Convert array to string

// Java example for Convert array to string
import java.util.Arrays;
class Execution
{
    public static void main(String[] args)
    {
        String[] myArray = new String[]
        {
            "Apple" , "Mango" , "Orange" , "Banana"
        };
        // Convert array to string
        System.out.println(Arrays.toString(myArray));
        String[][] multiArray = new String[][]
        {
            {
                "Monday" , "Tuesday" , "Wednesday" , "Thursday" , "Friday"
            },
            {
                "January" , "February" , "March" , "April" , "May"
            }
        };
        // Convert muti-array to string
        System.out.println(Arrays.deepToString(multiArray));
    }
}

Output

[Apple, Mango, Orange, Banana]
[[Monday, Tuesday, Wednesday, Thursday, Friday], [January, February, March, April, May]]


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved