Introduction to array

Introduction to Arrays in Java

An array in Java is a collection of elements of the same data type, stored in a contiguous block of memory. It is a fundamental data structure that allows you to store multiple values under a single variable name and access them using an index.

---

Key Features of Arrays in Java

1. Fixed Size: The size of an array is determined when it is created and cannot be changed.
2. Homogeneous Elements: All elements in an array must be of the same type.
3. Indexed Access: Elements are accessed using a zero-based index.
4. Efficient Access: Arrays allow direct access to elements, making them fast for read/write operations.
5. Reference Type: Arrays in Java are objects, and the memory for an array is allocated on the heap.

---

Declaration and Initialization of Arrays

1. Declaration

To declare an array, specify the data type followed by square brackets ([]) and the array name.

dataType[] arrayName; // Recommended

dataType arrayName[]; // Allowed but less common

2. Instantiation

You can allocate memory to an array using the new keyword.

arrayName = new dataType[size];

3. Initialization

An array can be initialized at the time of declaration or later.

// Combined declaration and initialization

int[] numbers = {1, 2, 3, 4, 5};

// Separate declaration, instantiation, and initialization

int[] numbers = new int[5]; // Array of size 5

numbers[0] = 10;

numbers[1] = 20;

---

Example: Declaring and Using an Array

public class Main {

    public static void main(String[] args) {

        // Declare and initialize an array

        int[] numbers = {10, 20, 30, 40, 50};

        // Access elements using an index

        System.out.println(“First Element: ” + numbers[0]); // Output: 10

        System.out.println(“Last Element: ” + numbers[numbers.length – 1]); // Output: 50

        // Loop through the array

        System.out.println(“Array Elements:”);

        for (int i = 0; i < numbers.length; i++) {

            System.out.println(numbers[i]);

        }

    }

}

---

Multidimensional Arrays

Java also supports multidimensional arrays, such as 2D arrays.

Declaration and Initialization of a 2D Array

int[][] matrix = {

    {1, 2, 3},

    {4, 5, 6},

    {7, 8, 9}

};

System.out.println(“Element at (1,2): ” + matrix[1][2]); // Output: 6

Iterating Over a 2D Array

for (int i = 0; i < matrix.length; i++) {

    for (int j = 0; j < matrix[i].length; j++) {

        System.out.print(matrix[i][j] + ” “);

    }

    System.out.println();

}

---

Advantages of Arrays

1. Easy Access: Elements can be accessed quickly using an index.
2. Compact Representation: Arrays provide an efficient way to store data of the same type.
3. Ease of Iteration: Arrays can be traversed using loops.

---

Limitations of Arrays

1. Fixed Size: Once defined, the size of an array cannot be changed dynamically.
2. No Built-in Methods: Arrays lack advanced functionality like searching or sorting (you need to write logic or use helper classes like Arrays).
3. Homogeneity: Arrays can only store elements of a single data type.

---

Common Operations on Arrays

1. Traversing an Array

int[] arr = {10, 20, 30, 40, 50};

for (int i = 0; i < arr.length; i++) {

    System.out.println(arr[i]);

}

2. Finding the Length of an Array

System.out.println(“Array Length: ” + arr.length);

3. Sorting an Array

import java.util.Arrays;

int[] arr = {50, 20, 10, 40, 30};

Arrays.sort(arr);

System.out.println(“Sorted Array: ” + Arrays.toString(arr));

---

Arrays vs ArrayList

Feature	Array	ArrayList
Size	Fixed at declaration time.	Dynamic; can grow or shrink.
Type	Can store primitives.	Stores objects (autoboxing for primitives).
Performance	Faster for fixed-size data.	Slower due to dynamic resizing.
Methods	No built-in methods.	Rich methods like add(), remove(), etc.

---

Conclusion

Arrays are a fundamental part of Java programming, offering an efficient way to store and manage data. While they are simple and fast, their fixed size and lack of advanced methods often make dynamic alternatives like ArrayList more practical for modern applications.