25 Interesting Facts about Arrays in Java

Java arrays are the workhorses of many programs, offering a structured way to store and manipulate data. While arrays are a fundamental concept, there are intriguing facts that developers may not be aware of for Java Arrays. In this blog post, we’ll explore 25 interesting facts about arrays in Java, shedding light on their nuances and capabilities.

1. Zero-Based Indexing:

Arrays in Java use zero-based indexing, meaning the first element is accessed with index 0, the second with index 1, and so on.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] numbers = { 10, 20, 30 };
        int firstElement
            = numbers[0]; // Accessing the first element
                          // (index 0)
        System.out.println(firstElement); // Output: 10
    }
}

Output

10

2. Fixed Size:

The size of an array in Java is fixed upon creation and cannot be changed afterward

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] fixedArray
            = new int[5]; // Array with a fixed size of 5
    }
}

3. Primitive and Object Types:

Arrays in Java can store both primitive data types (int, char, etc.) and objects.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] primitiveArray = { 1, 2, 3 };
        String[] objectArray
            = { "Java", "Arrays", "Example" };
    }
}

4. Reference Variables:

Arrays are objects in Java, and when declared, a reference variable is created.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] arrayReference = new int[3];
    }
}

5. Dynamic Initialization:

While the size of an array is fixed, its elements can be dynamically initialized.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] dynamicArray = new int[3];
        dynamicArray[0] = 10;
        dynamicArray[1] = 20;
        dynamicArray[2] = 30;
    }
}

6. Array Copying:

Java provides methods like System.arraycopy() and Arrays.copyOf() for efficient copying of arrays.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] sourceArray = { 1, 2, 3 };
        int[] destinationArray = new int[3];
        System.arraycopy(sourceArray, 0, destinationArray,
                         0, sourceArray.length);
    }
}

7. Varargs and Arrays:

Varargs (variable-length argument lists) in Java are implemented using arrays.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        void printNumbers(int... numbers)
        {
            for (int num : numbers) {
                System.out.print(num + " ");
            }
        }
        printNumbers(1, 2, 3, 4); // Output: 1 2 3 4
    }
}

8. Arrays.asList():

The Arrays.asList() method facilitates the conversion of arrays to Lists.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        String[] languages = { "Java", "Python", "C++" };
        List<String> languageList
            = Arrays.asList(languages);
    }
}

9. Array Equality:

Arrays do not override the equals() method in Java’s Object class.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] array1 = { 1, 2, 3 };
        int[] array2 = { 1, 2, 3 };
        boolean areEqual = Arrays.equals(array1, array2);
        System.out.println(areEqual); // Output: true
    }
}

10. The Enhanced for Loop:

The enhanced for loop introduced in Java 5 simplifies array traversal.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] numbers = { 1, 2, 3 };
        for (int num : numbers) {
            System.out.print(num + " ");
        }
        // Output: 1 2 3
    }
}

Output

1 2 3 

11. Cloneable Interface:

Arrays implement the Cloneable interface, allowing developers to create a copy of an array using the clone() method.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] originalArray = { 1, 2, 3 };
        int[] clonedArray = originalArray.clone();
    }
}

12. Arrays.deepToString():

For multi-dimensional arrays, the Arrays.deepToString() method provides a convenient way to print the contents.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[][] matrix
            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
        System.out.println(Arrays.deepToString(matrix));
        // Output: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    }
}

13. Arrays.sort():

The Arrays.sort() method efficiently sorts arrays.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] unsortedArray = { 3, 1, 4, 1, 5, 9, 2 };
        Arrays.sort(unsortedArray);
        System.out.println(Arrays.toString(unsortedArray));
        // Output: [1, 1, 2, 3, 4, 5, 9]
    }
}

14. Parallel Array Sorting:

Starting from Java 8, arrays can be sorted in parallel using Arrays.parallelSort().

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] unsortedArray = { 3, 1, 4, 1, 5, 9, 2 };
        Arrays.parallelSort(unsortedArray);
        System.out.println(Arrays.toString(unsortedArray));
        // Output: [1, 1, 2, 3, 4, 5, 9]
    }
}

15. Jagged Arrays:

Java supports jagged arrays, where each row in a multi-dimensional array can have a different length.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[][] jaggedArray
            = { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8, 9 } };
    }
}

16. Memory Efficiency:

Arrays in Java are memory-efficient, storing elements of the same type contiguously in memory.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] initializedArray = { 1, 2, 3, 4, 5 };
    }
}

Output

17. Array Initialization Shortcut:

When declaring an array, Java allows direct initialization with values.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] initializedArray = { 1, 2, 3, 4, 5 };
    }
}

18. Array Length Attribute:

The length attribute of an array provides a quick way to obtain its size.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] array = { 10, 20, 30 };
        int arrayLength = array.length;
    }
}

19. ArrayDeque vs. Arrays:

While ArrayDeque is a dynamic array-based implementation of a deque, arrays themselves are a fundamental building block for such data structures.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        deque.add(1);
        deque.add(2);
        deque.add(3);
    }
}

20. Arrays.fill():

The Arrays.fill() method efficiently populates an entire array with a specified value.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] filledArray = new int[5];
        Arrays.fill(filledArray, 42);
    }
}

21. Garbage Collection:

Arrays, like other objects in Java, are subject to garbage collection.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] arrayToBeCollected = { 1, 2, 3 };
        arrayToBeCollected
            = null; // Making the array eligible for garbage
                    // collection
    }
}

22. Array Reflection:

Java’s reflection API allows developers to inspect and manipulate arrays at runtime.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        Class<?> arrayClass = Class.forName(
            "[I"); // [I represents an int array
    }
}

23. Arrays and Generics:

Arrays and generics have some compatibility issues due to type erasure.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Generic array creation is not allowed
        List<String>[] arrayOfLists = new List[5];
    }
}

24. Array Performance:

Accessing elements in an array is a constant-time operation, making arrays highly efficient for random access scenarios.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] array = { 1, 2, 3, 4, 5 };
        int thirdElement = array[2];
    }
}

25. Arrays in Streams:

With the introduction of the Stream API in Java 8, arrays seamlessly integrate into stream processing.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        int sum = Arrays.stream(numbers).sum();
        System.out.println(sum); // Output: 15
    }
}

Understanding these facts about arrays provides a solid foundation for leveraging their power in Java programming. Arrays in Java are a foundational element of the language, offering a powerful mechanism for data storage and manipulation. Understanding the intricacies of arrays enhances a developer’s ability to write efficient and error-free code. Whether dealing with simple arrays or complex multi-dimensional structures, these 25 facts illuminate the diverse capabilities and nuances of arrays in Java.