DocumentationProgramsSponsorsPlayground

Java Program to Work with Arrays - Operations and Examples

Learn essential array operations in Java including initialization, searching, sorting, and manipulation with comprehensive examples and explanations.

In this program, you'll learn to work with arrays by performing common operations like initialization, searching, sorting, and manipulation.

To understand this example, you should have the knowledge of the following Java programming topics:

Array Operations Program

Example 1: Basic Array Operations

class BasicArrayOperations {
    public static void main(String[] args) {
        // Array initialization
        int[] numbers = {45, 23, 67, 12, 89, 34, 56};

        System.out.println("=== Original Array ===");
        printArray(numbers);

        // Find maximum and minimum
        int max = findMaximum(numbers);
        int min = findMinimum(numbers);

        System.out.println("\nMaximum value: " + max);
        System.out.println("Minimum value: " + min);

        // Calculate sum and average
        int sum = calculateSum(numbers);
        double average = (double) sum / numbers.length;

        System.out.println("Sum: " + sum);
        System.out.println("Average: " + average);

        // Search for specific elements
        int searchValue = 67;
        int index = searchElement(numbers, searchValue);

        if (index != -1) {
            System.out.println("\nElement " + searchValue + " found at index: " + index);
        } else {
            System.out.println("\nElement " + searchValue + " not found in array");
        }
    }

    // Method to print array
    static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println();
    }

    // Method to find maximum value
    static int findMaximum(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    // Method to find minimum value
    static int findMinimum(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    // Method to calculate sum
    static int calculateSum(int[] arr) {
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        return sum;
    }

    // Method to search for an element
    static int searchElement(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1; // Element not found
    }
}

Output:

=== Original Array ===
45, 23, 67, 12, 89, 34, 56

Maximum value: 89
Minimum value: 12
Sum: 326
Average: 46.57142857142857

Element 67 found at index: 2

Example 2: Array Sorting and Manipulation

import java.util.Arrays;

class ArraySortingOperations {
    public static void main(String[] args) {
        int[] numbers = {64, 34, 25, 12, 22, 11, 90};

        System.out.println("=== Original Array ===");
        printArray(numbers);

        // Bubble sort implementation
        int[] bubbleSorted = numbers.clone();
        bubbleSort(bubbleSorted);
        System.out.println("\n=== After Bubble Sort ===");
        printArray(bubbleSorted);

        // Reverse array
        int[] reversed = numbers.clone();
        reverseArray(reversed);
        System.out.println("\n=== Reversed Array ===");
        printArray(reversed);

        // Find second largest element
        int secondLargest = findSecondLargest(numbers);
        System.out.println("\nSecond largest element: " + secondLargest);

        // Count even and odd numbers
        countEvenOdd(numbers);

        // Using built-in sort
        int[] builtInSorted = numbers.clone();
        Arrays.sort(builtInSorted);
        System.out.println("\n=== Built-in Sort Result ===");
        printArray(builtInSorted);
    }

    static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }

    // Bubble sort implementation
    static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Swap elements
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // Reverse array
    static void reverseArray(int[] arr) {
        int start = 0;
        int end = arr.length - 1;

        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    // Find second largest element
    static int findSecondLargest(int[] arr) {
        int largest = Integer.MIN_VALUE;
        int secondLargest = Integer.MIN_VALUE;

        for (int num : arr) {
            if (num > largest) {
                secondLargest = largest;
                largest = num;
            } else if (num > secondLargest && num != largest) {
                secondLargest = num;
            }
        }

        return secondLargest;
    }

    // Count even and odd numbers
    static void countEvenOdd(int[] arr) {
        int evenCount = 0;
        int oddCount = 0;

        for (int num : arr) {
            if (num % 2 == 0) {
                evenCount++;
            } else {
                oddCount++;
            }
        }

        System.out.println("\nEven numbers count: " + evenCount);
        System.out.println("Odd numbers count: " + oddCount);
    }
}

Output:

=== Original Array ===
[64, 34, 25, 12, 22, 11, 90]

=== After Bubble Sort ===
[11, 12, 22, 25, 34, 64, 90]

=== Reversed Array ===
[90, 11, 22, 12, 25, 34, 64]

Second largest element: 64

Even numbers count: 4
Odd numbers count: 3

=== Built-in Sort Result ===
[11, 12, 22, 25, 34, 64, 90]

Example 3: Interactive Array Program

import java.util.Scanner;

class InteractiveArrayProgram {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter the size of the array: ");
        int size = scanner.nextInt();

        int[] numbers = new int[size];

        // Input array elements
        System.out.println("Enter " + size + " integers:");
        for (int i = 0; i < size; i++) {
            System.out.print("Element " + (i + 1) + ": ");
            numbers[i] = scanner.nextInt();
        }

        while (true) {
            System.out.println("\n=== Array Operations Menu ===");
            System.out.println("1. Display Array");
            System.out.println("2. Find Maximum");
            System.out.println("3. Find Minimum");
            System.out.println("4. Calculate Sum");
            System.out.println("5. Search Element");
            System.out.println("6. Sort Array");
            System.out.println("7. Reverse Array");
            System.out.println("8. Exit");
            System.out.print("Choose an option: ");

            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("Array: " + Arrays.toString(numbers));
                    break;

                case 2:
                    System.out.println("Maximum: " + findMax(numbers));
                    break;

                case 3:
                    System.out.println("Minimum: " + findMin(numbers));
                    break;

                case 4:
                    System.out.println("Sum: " + calculateSum(numbers));
                    break;

                case 5:
                    System.out.print("Enter element to search: ");
                    int searchValue = scanner.nextInt();
                    int index = linearSearch(numbers, searchValue);
                    if (index != -1) {
                        System.out.println("Element found at index: " + index);
                    } else {
                        System.out.println("Element not found!");
                    }
                    break;

                case 6:
                    Arrays.sort(numbers);
                    System.out.println("Array sorted successfully!");
                    break;

                case 7:
                    reverseArray(numbers);
                    System.out.println("Array reversed successfully!");
                    break;

                case 8:
                    System.out.println("Thank you for using the array program!");
                    scanner.close();
                    return;

                default:
                    System.out.println("Invalid choice! Please try again.");
            }
        }
    }

    static int findMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    static int findMin(int[] arr) {
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    static int calculateSum(int[] arr) {
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        return sum;
    }

    static int linearSearch(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }

    static void reverseArray(int[] arr) {
        int start = 0;
        int end = arr.length - 1;

        while (start < end) {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }
}

Sample Output:

Enter the size of the array: 5
Enter 5 integers:
Element 1: 10
Element 2: 20
Element 3: 15
Element 4: 25
Element 5: 5

=== Array Operations Menu ===
1. Display Array
2. Find Maximum
3. Find Minimum
4. Calculate Sum
5. Search Element
6. Sort Array
7. Reverse Array
8. Exit
Choose an option: 1
Array: [10, 20, 15, 25, 5]

=== Array Operations Menu ===
1. Display Array
2. Find Maximum
3. Find Minimum
4. Calculate Sum
5. Search Element
6. Sort Array
7. Reverse Array
8. Exit
Choose an option: 2
Maximum: 25

Key Array Operations Covered

  1. Array Declaration and Initialization
  2. Element Access and Modification
  3. Searching Algorithms (Linear Search)
  4. Sorting Algorithms (Bubble Sort, Built-in Sort)
  5. Array Traversal (for loop, enhanced for loop)
  6. Mathematical Operations (sum, average, max, min)
  7. Array Manipulation (reverse, copy)

Important Array Methods

  • Arrays.toString() - Convert array to string
  • Arrays.sort() - Sort array using built-in algorithm
  • Arrays.copyOf() - Create a copy of array
  • arr.length - Get array length
  • arr.clone() - Create a shallow copy

Next Steps

Try extending these programs by:

  1. Implementing binary search for sorted arrays
  2. Working with 2D arrays (matrices)
  3. Creating array of objects
  4. Implementing more sorting algorithms
  5. Adding array comparison operations