Array Data Structure Explained — How Arrays Work, Why They Matter, and How to Use Them

public class ArrayMemoryDemo {
    public static void main(String[] args) {

        // Declare and create an array of 5 student scores.
        // Java reserves 5 consecutive int-sized slots in memory right now.
        // Each int in Java takes 4 bytes, so this reserves 20 bytes in a row.
        int[] studentScores = new int[5];

        // Assign values to each slot using the index (offset from start).
        // Index 0 = first slot (0 steps from the start)
        // Index 4 = last slot (4 steps from the start)
        studentScores[0] = 91;  // first student
        studentScores[1] = 78;  // second student
        studentScores[2] = 85;  // third student
        studentScores[3] = 62;  // fourth student
        studentScores[4] = 99;  // fifth student

        // Access any element instantly by its index — no looping needed.
        // The JVM computes: base_address + (3 * 4 bytes) = value at index 3
        System.out.println("Score at index 3: " + studentScores[3]);

        // .length gives us the number of slots (declared size), not the last index.
        // Last valid index is always length - 1.
        System.out.println("Total slots reserved: " + studentScores.length);
        System.out.println("Last valid index    : " + (studentScores.length - 1));

        // Shorthand: declare and fill in one line using an array literal.
        // Java counts the values and sets the size automatically (5 here).
        int[] dailySteps = {4200, 8100, 6750, 9300, 7050};
        System.out.println("\nSteps on day 1 (index 0): " + dailySteps[0]);
        System.out.println("Steps on day 5 (index 4): " + dailySteps[4]);
    }
}

public class ArrayIterationPatterns {
    public static void main(String[] args) {

        int[] monthlyRainfall = {45, 30, 55, 80, 120, 95, 110, 105, 70, 40, 25, 50};
        // Represents rainfall in mm for Jan through Dec

        // ── PATTERN 1: Classic for loop (use when you need the index) ──────────
        System.out.println("=== Monthly Rainfall Report ===");
        String[] monthNames = {"Jan","Feb","Mar","Apr","May","Jun",
                               "Jul","Aug","Sep","Oct","Nov","Dec"};

        for (int i = 0; i < monthlyRainfall.length; i++) {
            // i is the index — it lets us look up the matching month name
            System.out.println(monthNames[i] + ": " + monthlyRainfall[i] + " mm");
        }

        // ── PATTERN 2: Enhanced for-each (use when you only need values) ───────
        // Accumulator pattern: start total at 0, add each value to it
        int totalRainfall = 0;
        for (int rainfall : monthlyRainfall) {
            // 'rainfall' is a COPY of each element — we're just reading, which is fine
            totalRainfall += rainfall;
        }
        System.out.println("\nTotal annual rainfall: " + totalRainfall + " mm");
        System.out.printf("Monthly average      : %.1f mm%n",
                          (double) totalRainfall / monthlyRainfall.length);

        // ── PATTERN 3: Finding the maximum (running champion pattern) ───────────
        // Start by assuming the first element is the biggest.
        // Then challenge it with every other element.
        int peakRainfall = monthlyRainfall[0]; // our current champion
        int peakMonth    = 0;                  // index of the champion

        for (int i = 1; i < monthlyRainfall.length; i++) { // start at 1, we already stored [0]
            if (monthlyRainfall[i] > peakRainfall) {
                peakRainfall = monthlyRainfall[i]; // new champion found
                peakMonth    = i;
            }
        }
        System.out.println("\nWettest month: " + monthNames[peakMonth]
                           + " with " + peakRainfall + " mm");
    }
}

public class CinemaSeatingGrid {
    public static void main(String[] args) {

        // A small cinema: 3 rows, 5 seats per row
        // true = seat is booked, false = seat is available
        // Outer array index = row number (0, 1, 2)
        // Inner array index = seat number within that row (0, 1, 2, 3, 4)
        boolean[][] cinemaSeats = {
            {true,  false, true,  true,  false},  // Row 0 (front)
            {false, false, false, true,  true },  // Row 1 (middle)
            {true,  true,  false, false, false}   // Row 2 (back)
        };

        // Print the seating plan
        // [B] = booked, [_] = available
        System.out.println("=== Cinema Seating Plan ===");
        System.out.println("     Seat: 1    2    3    4    5");

        for (int row = 0; row < cinemaSeats.length; row++) {
            System.out.print("Row " + (row + 1) + ":  ");

            for (int seat = 0; seat < cinemaSeats[row].length; seat++) {
                // cinemaSeats[row][seat] is the specific cell
                System.out.print(cinemaSeats[row][seat] ? "[B]  " : "[_]  ");
            }
            System.out.println(); // move to next line after each row
        }

        // Count available seats using nested loops
        int availableCount = 0;
        for (boolean[] row : cinemaSeats) {          // each row is itself an array
            for (boolean seatBooked : row) {         // each element is a boolean
                if (!seatBooked) availableCount++;   // if NOT booked, it's available
            }
        }
        System.out.println("\nAvailable seats: " + availableCount
                           + " out of " + (cinemaSeats.length * cinemaSeats[0].length));

        // Direct access: book seat 3 in row 1 (using 0-based indexes: row=1, seat=2)
        cinemaSeats[1][2] = true;
        System.out.println("Seat 3 in Row 2 is now booked: " + cinemaSeats[1][2]);
    }
}

import java.util.ArrayList;

public class ArrayVsArrayList {
    public static void main(String[] args) {

        // ── RAW ARRAY: Fixed size, fast, lightweight ─────────────────────────
        // Perfect here because there are always exactly 7 days in a week.
        double[] weeklyTemperatures = {18.5, 21.0, 19.8, 23.4, 25.1, 22.7, 20.3};
        System.out.println("=== Fixed-Size Array (Weekly Temperatures) ===");
        for (int day = 0; day < weeklyTemperatures.length; day++) {
            System.out.printf("Day %d: %.1f°C%n", day + 1, weeklyTemperatures[day]);
        }

        // ── ARRAYLIST: Dynamic size, flexible ────────────────────────────────
        // Perfect here because we don't know how many items a user will add.
        ArrayList<String> shoppingCart = new ArrayList<>(); // starts empty, grows as needed

        shoppingCart.add("Apples");       // add() appends to the end
        shoppingCart.add("Bread");
        shoppingCart.add("Orange Juice");
        System.out.println("\n=== Dynamic ArrayList (Shopping Cart) ===");
        System.out.println("Cart after adding 3 items: " + shoppingCart);

        shoppingCart.remove("Bread");     // remove by value — not possible with raw arrays
        System.out.println("Cart after removing Bread: " + shoppingCart);
        System.out.println("Number of items in cart  : " + shoppingCart.size()); // .size() not .length

        // Accessing by index works the same way — .get(index) replaces [index]
        System.out.println("First item in cart: " + shoppingCart.get(0));
    }
}