DEV Community

Cover image for Arrays in Java: Characteristics, Usage, and Real-Life Scenarios
Alex Ricciardi
Alex Ricciardi

Posted on • Originally published at Medium

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]);
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

Outputs:

Product 1 Quantity: 50
Product 2 Quantity: 30
Product 3 Quantity: 20
Product 4 Quantity: 40
Enter fullscreen mode Exit fullscreen mode

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!");
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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]));
    }
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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.

Heroku

Simplify your DevOps and maximize your time.

Since 2007, Heroku has been the go-to platform for developers as it monitors uptime, performance, and infrastructure concerns, allowing you to focus on writing code.

Learn More

Top comments (0)

A Workflow Copilot. Tailored to You.

Pieces.app image

Our desktop app, with its intelligent copilot, streamlines coding by generating snippets, extracting code from screenshots, and accelerating problem-solving.

Read the docs

👋 Kindness is contagious

Explore a sea of insights with this enlightening post, highly esteemed within the nurturing DEV Community. Coders of all stripes are invited to participate and contribute to our shared knowledge.

Expressing gratitude with a simple "thank you" can make a big impact. Leave your thanks in the comments!

On DEV, exchanging ideas smooths our way and strengthens our community bonds. Found this useful? A quick note of thanks to the author can mean a lot.

Okay