Arrays in Java: Characteristics, Usage, and Real-Life Scenarios

This article explores the characteristics of arrays in Java, such as their fixed size, efficient access, and type safety, while comparing them to dynamic collection types like ArrayList. It also provides real-life scenarios, such as storing product quantities, modifying daily temperatures, and sorting student grades, to demonstrate practical applications of arrays in Java.

---

In Java, arrays are a fundamental data structure that allows developers to store multiple values of the same type in a single variable. Arrays provide an efficient way to manage and manipulate data due to their fixed size and direct access capabilities. This article will explore the characteristics of Java arrays, compare them to other collection types like ArrayList, and present real-life scenarios where arrays are useful. Understanding the properties and applications of arrays is essential for building efficient Java programs.

Below is a list of array characteristics in Java:

• Fixed Size: Once defined, the size of an array cannot be changed.
• Ordered: Arrays store elements in a sequential order which means that elements can be accessed by their index in constant time.
• Efficiency: Accessing any element in an array is a constant time operation. Arrays have a very low memory overhead because they store a single type of data.
• Single Type: Java arrays are typed, which means they can only store elements of the same data type as declared in the array declaration.

Arrays are different from ArrayList, which are lists and are part of the Collection Interface. An Interface in Java is a reference type, similar to a class, that can contain only constants, default methods, static methods, and nested types (Tutorials Point, n. d.). In the case of the Collection Interface, it includes methods like add(), remove(), get(), and size(), among others (Oracle Doc., n.d.). This allows different types of list classes, such as ArrayList, LinkedList, and others like the Set class, to use those methods.

Note that arrays are not part of the Collection Interface. In other words, they do not have methods associated with them.

Real-Life Scenarios for Using Arrays

Scenario 1 Store Product Quantities in a Store:
An array can be used to keep track of the quantities of different products in a store. For example, each element of the array represents the quantity of a specific product.

public class Main {
    public static void main(String[] args) {
        // Stores product quantities
        int[] quantities = new int[4];   
        // Storing product quantities
        quantities[0] = 50;  
        quantities[1] = 30;  
        quantities[2] = 20;  
        quantities[3] = 40;  
        // Prints the product quantities
        for (int i = 0; i < quantities.length; i++) {
            System.out.println("Product " + (i + 1) + " Quantity: " 
                                                            +   quantities[i]);
        }
    }
}

Outputs:

Product 1 Quantity: 50
Product 2 Quantity: 30
Product 3 Quantity: 20
Product 4 Quantity: 40

Scenario-2:
An array can be used to store and modify daily temperatures.

public class Main {
    public static void main(String[] args) {
        // Stores daily temperatures 
        int[] temperatures = {68, 70, 75, 72, 69, 71, 73};

        // Prints initial temperatures
        System.out.println("Initial daily temperatures:");
        printTemperatures(temperatures);

        // Modifies temperatures
        modifyTemperature(temperatures, 2, 78);
        modifyTemperature(temperatures, 5, 74);

        // Prints updated temperatures
        System.out.println("\nUpdated daily temperatures:");
        printTemperatures(temperatures);
    }

    // Method to print all temperatures
    public static void printTemperatures(int[] temperatures) {
        String[] days = {"Monday", "Tuesday", "Wednesday", "Thursday", 
                         "Friday","Saturday", "Sunday"};
        for (int i = 0; i < temperatures.length; i++) {
            System.out.println(days[i] + ": " + temperatures[i] + "°F");
        }
    }

    // Method to modify a temperature
    public static void modifyTemperature(int[] temperatures, int dayIndex, 
                                                               int newTemperature) {
        if (dayIndex >= 0 && dayIndex < temperatures.length) {
            temperatures[dayIndex] = newTemperature;
        } else {
            System.out.println("Invalid day index!");
        }
    }
}

Outputs:

Initial daily temperatures:
Monday: 68°F
Tuesday: 70°F
Wednesday: 75°F
Thursday: 72°F
Friday: 69°F
Saturday: 71°F
Sunday: 73°F

Updated daily temperatures:
Monday: 68°F
Tuesday: 70°F
Wednesday: 78°F
Thursday: 72°F
Friday: 69°F
Saturday: 74°F
Sunday: 73°F

Scenario-3:
An array can be used to store and sort students’ grades in a particular class.

import java.util.Arrays;public class Main{
    public static void main(String[] args) {
        // Two-dimensional array to store student IDs and their grades
        int[][] studentGrades = {
            {1, 85}, // {Student ID, Grade}
            {2, 90},
            {3, 78},
            {4, 92},
            {5, 88}
        };

        // Prints initial student grades
        System.out.println("Initial student grades:");
        printAllGrades(studentGrades);
        // Sorting grades from lowest to highest
        sortGrades(studentGrades);
        // Printing sorted student grades
        System.out.println("\nSorted student grades:");
        printAllGrades(studentGrades);
    }
    // Prints all grades
    public static void printAllGrades(int[][] studentGrades) {
        for (int i = 0; i < studentGrades.length; i++) {
            System.out.println("Student ID " + studentGrades[i][0] 
                                + ": " + studentGrades[i][1]);
        }
    }
    // Sorts grades 
    public static void sortGrades(int[][] studentGrades) {
        Arrays.sort(studentGrades, (a, b) -> Integer.compare(a[1], b[1]));
    }
}

Outputs

Initial student grades:
Student ID 1: 85
Student ID 2: 90
Student ID 3: 78
Student ID 4: 92
Student ID 5: 88

Sorted student grades:
Student ID 3: 78
Student ID 1: 85
Student ID 5: 88
Student ID 2: 90
Student ID 4: 92

To summarize, Java arrays have a fixed size, they store multiple values of the same type. They offer efficient, constant access to elements by using indexes, making them suitable for scenarios where memory overhead and speed are a concern. While arrays do not provide the flexibility of collections like ArrayList, they still are an invaluable part of Java’s toolkit for handling ordered data efficiently.

---

References:

Oracle Doc. (n.d.). Collection (Java SE 21) [Java Platform, Standard Edition Java API Specification]. Oracle. Retrieved from https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Collection.html/

Tutorials Point. (n.d.). Java interfaces. Tutorials Point. Retrieved from https://www.tutorialspoint.com/java/java_interfaces.htm

---

Originally published at Alex.omegapy on Medium published by Level UP Coding on October 16, 2024.