Java Programming: Array Operations and Sorting

Table of Contents

1. Introduction to Arrays in Java
2. Creating and Initializing Arrays
3. Basic Array Operations
   • Accessing Elements
   • Modifying Elements
   • Finding the Length of an Array
4. Common Array Methods
   • Arrays.toString()
   • Arrays.fill()
   • Arrays.copyOf()
   • Arrays.equals()
5. Sorting Arrays
   • Using Arrays.sort()
   • Custom Sorting with Comparator
6. Multi-Dimensional Arrays
7. Complete Example

1. Introduction to Arrays in Java

An array is a collection of elements of similar types. Each element in an array is accessed via an index, starting from 0.

2. Creating and Initializing Arrays

You can declare and initialize arrays in various ways:

Declaration

dataType[] arrayName;

Initialization

Using New Keyword

dataType[] arrayName = new dataType[arraySize];

Example:

int[] numbers = new int[5];

Direct Initialization

dataType[] arrayName = {element1, element2, ..., elementN};

Example:

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

3. Basic Array Operations

Accessing Elements

dataType element = arrayName[index];

Example:

int num = numbers[0]; // Accesses the first element

Modifying Elements

arrayName[index] = newValue;

Example:

numbers[0] = 10; // Changes the first element to 10

Finding the Length of an Array

int length = arrayName.length;

Example:

int length = numbers.length; // Length is 5

4. Common Array Methods

Import the java.util.Arrays class to use these methods.

Arrays.toString()

Converts array to a string representation.

String str = Arrays.toString(arrayName);

Example:

System.out.println(Arrays.toString(numbers)); // Output: [10, 2, 3, 4, 5]

Arrays.fill()

Fills the array with a specific value.

Arrays.fill(arrayName, value);

Example:

Arrays.fill(numbers, 0); // Fills array with 0s: [0, 0, 0, 0, 0]

Arrays.copyOf()

Creates a copy of an array.

dataType[] newArray = Arrays.copyOf(arrayName, newLength);

Example:

int[] newNumbers = Arrays.copyOf(numbers, 6); // [0, 0, 0, 0, 0, 0]

Arrays.equals()

Checks if two arrays are equal.

boolean isEqual = Arrays.equals(array1, array2);

Example:

int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};
System.out.println(Arrays.equals(array1, array2)); // Output: true

5. Sorting Arrays

Using Arrays.sort()

Sorts an array in ascending order.

Arrays.sort(arrayName);

Example:

int[] numbers = {5, 3, 4, 1, 2};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // Output: [1, 2, 3, 4, 5]

Custom Sorting with Comparator (for Objects)

For custom sorting, use a Comparator.

Example:

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        String[] words = {"banana", "apple", "cherry"};
        Arrays.sort(words, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1); // Sort in descending order
            }
        });
        System.out.println(Arrays.toString(words)); // Output: [cherry, banana, apple]
    }
}

6. Multi-Dimensional Arrays

Multi-dimensional arrays are arrays of arrays.

Declaration and Initialization

Using New Keyword

dataType[][] arrayName = new dataType[rows][columns];

Example:

int[][] matrix = new int[3][3];

Direct Initialization

dataType[][] arrayName = {
    {element1, element2, ...},
    {element1, element2, ...},
    ...
};

Example:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

Accessing and Modifying Elements

dataType element = arrayName[rowIndex][columnIndex];
arrayName[rowIndex][columnIndex] = newValue;

Example:

int value = matrix[0][0]; // Accesses 1
matrix[0][0] = 10;        // Changes to 10

7. Complete Example

Let's put everything together in a complete example:

import java.util.Arrays;
import java.util.Comparator;

public class ArrayOperations {
    public static void main(String[] args) {
        // Creating and Initializing an Array
        int[] numbers = {5, 3, 4, 1, 2};
        System.out.println("Original array: " + Arrays.toString(numbers));

        // Basic Operations
        int firstElement = numbers[0];
        System.out.println("First element: " + firstElement);

        numbers[0] = 10;
        System.out.println("Modified array: " + Arrays.toString(numbers));

        int length = numbers.length;
        System.out.println("Length of array: " + length);

        // Common Array Methods
        Arrays.fill(numbers, 0);
        System.out.println("Filled array: " + Arrays.toString(numbers));

        int[] newNumbers = Arrays.copyOf(numbers, 6);
        System.out.println("Copied array: " + Arrays.toString(newNumbers));

        // Sorting Arrays
        Arrays.sort(newNumbers);
        System.out.println("Sorted array: " + Arrays.toString(newNumbers));

        // Custom Sorting (for objects)
        String[] words = {"banana", "apple", "cherry"};
        Arrays.sort(words, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1); // Sort in descending order
            }
        });
        System.out.println("Sorted words array: " + Arrays.toString(words));

        // Multi-Dimensional Arrays
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        System.out.println("Matrix:");
        for (int[] row : matrix) {
            System.out.println(Arrays.toString(row));
        }
    }
}

Explanation

1. Creating and Initializing Arrays:

   • We declare and initialize an integer array numbers.

2. Basic Operations:

   • Access the first element of the array.
   • Modify the first element of the array.
   • Print the length of the array.

3. Common Array Methods:

   • Fill the array with 0s.
   • Copy the array to a new array with a new size.
   • Sort the copied array in ascending order.

4. Sorting Arrays:

   • Sort a string array in descending order using a custom comparator.

5. Multi-Dimensional Arrays:

   • Declare and initialize a 2D array matrix.
   • Print each row of the matrix.

Output