public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess {

    private static final int DEFAULT_CAPACITY = 10;

    transient Object[] elementData;   // the internal array where the elements live
    private int size;                 // how many elements there REALLY are
}

List<String> names = new ArrayList<>();
System.out.println(names.size());         // 0  (internal capacity: 10 as soon as you add the first)
names.add("Marta Ruiz");
names.add("Diego Alonso");
System.out.println(names.size());         // 2

ArrayList<Material> list = new ArrayList<>(1000);
// ... only 30 get filled ...
list.trimToSize();       // reduces the internal capacity to 30

// inside ArrayList, simplified:
private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);   // capacity * 1.5
    return elementData = Arrays.copyOf(elementData, newCapacity);
}

List<Material> a = new ArrayList<>();                    // default capacity (10 once filled)
List<Material> b = new ArrayList<>(500);                 // initial capacity 500
List<Material> c = new ArrayList<>(otherCollection);     // copy at exactly the right size

// Loading the whole catalogue: we know it is about 5000 materials
List<Material> catalog = new ArrayList<>(5000);
for (String line : fileLines) {
    catalog.add(convert(line));
}

List<Material> independentCopy = new ArrayList<>(catalog);        // modifiable shallow copy
List<String>   fromASet        = new ArrayList<>(isbnSet);
List<String>   fromAFixedList  = new ArrayList<>(List.of("a", "b", "c"));   // now it IS modifiable

import java.util.ArrayList;
import java.util.List;

List<Material> catalog = new ArrayList<>();

catalog.add(new Book("Effective Java",  "Joshua Bloch",  "978-0000000001", 2018));
catalog.add(new Book("Design Patterns", "Erich Gamma",   "978-0000000002", 1994));
catalog.add(new Book("Refactoring",     "Martin Fowler", "978-0000000003", 1999));
catalog.add(new Magazine("Java Magazine", "REV-2024-03", 42, "Monthly"));
catalog.add(new Dvd("Refactoring Live", "DVD-0007",      95));

// MODIFIABLE list from loose elements
List<String> employees = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal"));

// IMMUTABLE list (careful: add will throw UnsupportedOperationException)
List<String> fixed = List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal");

// Adding several at once to an existing list
catalog.addAll(otherMaterials);
Collections.addAll(catalog, material1, material2, material3);

List<String> l = new ArrayList<>(List.of("A", "B", "C"));

l.add("D");                 // [A, B, C, D]   at the end, amortised O(1)
l.add(1, "X");              // [A, X, B, C, D] at position 1, O(n): shifts the rest
l.addAll(List.of("E","F")); // [A, X, B, C, D, E, F]
l.addAll(0, List.of("Z"));  // [Z, A, X, B, C, D, E, F]

String first = l.get(0);            // O(1)
String last  = l.get(l.size()-1);   // the idiom for the last element

String previous = l.set(1, "Y");    // REPLACES and returns what was there. O(1)

l.remove(0);                  // by INDEX, returns the removed element
l.remove("B");                // by OBJECT, returns a boolean. Uses equals
l.removeIf(s -> s.isEmpty()); // by CRITERION, returns a boolean
l.clear();                    // empties the list

boolean there = l.contains("C");     // O(n), uses equals
int pos       = l.indexOf("C");      // first occurrence, or -1 if absent. O(n)
int lastPos   = l.lastIndexOf("C");  // last occurrence

class MaterialWithoutEquals { /* does not override equals */ }

List<Card> cards = new ArrayList<>();
cards.add(new Card("Effective Java", "Joshua Bloch", 2018));

// Card is a record: generated equals, compares components
System.out.println(cards.contains(new Card("Effective Java", "Joshua Bloch", 2018)));  // true

// If Card were a normal class without equals:
// System.out.println(...) -> false, even though the data is identical

l.replaceAll(String::toUpperCase);              // applies a UnaryOperator to each element
l.sort(Comparator.naturalOrder());              // sorts in place
l.sort(Comparator.comparing(Material::getTitle));
l.forEach(System.out::println);                 // traverses applying a Consumer

List<Material> catalog = ...;
catalog.sort(Comparator.comparing(Material::getType)
                       .thenComparing(Material::getTitle));

int n         = l.size();
boolean empty = l.isEmpty();       // preferable to size() == 0: more readable

E       remove(int index);       // removes by POSITION
boolean remove(Object o);        // removes by VALUE

List<Integer> numbers = new ArrayList<>(List.of(10, 20, 30, 40));

numbers.remove(1);                  // what does it remove?
System.out.println(numbers);        // [10, 30, 40]  <- it removed POSITION 1, not the value 1

List<Integer> ids = new ArrayList<>(List.of(100, 200, 300));
ids.remove(100);         // IndexOutOfBoundsException: Index 100 out of bounds for length 3

List<Integer> numbers = new ArrayList<>(List.of(10, 20, 30, 40));

numbers.remove(Integer.valueOf(20));    // 1. explicit: by VALUE
numbers.remove((Integer) 30);           // 2. cast: by VALUE
numbers.remove(1);                      // 3. by POSITION (it is clear that is what you want)

List<String> l = new ArrayList<>(List.of("A", "B", "C", "D", "E"));
List<String> middle = l.subList(1, 4);     // [B, C, D]

middle.set(0, "X");
System.out.println(l);         // [A, X, C, D, E]   <- the ORIGINAL has changed

middle.clear();
System.out.println(l);         // [A, E]            <- they were deleted from the ORIGINAL

List<String> l = new ArrayList<>(List.of("A", "B", "C", "D", "E"));
List<String> middle = l.subList(1, 4);
l.add("F");                          // structural modification of the original
System.out.println(middle);          // ConcurrentModificationException

List<String> copyOfMiddle = new ArrayList<>(l.subList(1, 4));     // now it IS independent

// Paging results without copying the whole list
int from = page * perPage;
int to   = Math.min(from + perPage, results.size());
List<Material> currentPage = results.subList(from, to);

// Deleting a whole range
catalog.subList(0, 10).clear();           // removes the first 10

// Sorting only a stretch
catalog.subList(0, 5).sort(Comparator.comparing(Material::getTitle));

// 1. for-each: by default, when you only read
for (Material m : catalog) {
    System.out.println(m.describe());
}

// 2. classic for with an index: when you need the position or write with set
for (int i = 0; i < catalog.size(); i++) {
    System.out.printf("%2d. %s%n", i + 1, catalog.get(i).getTitle());
}

// 3. forEach with a Consumer: when you already have the action as a method reference
catalog.forEach(System.out::println);

// CORRECT AND PREFERRED: one line
catalog.removeIf(m -> !m.isAvailable());

// CORRECT: explicit iterator, when the logic is complex
Iterator<Material> it = catalog.iterator();
while (it.hasNext()) {
    Material m = it.next();
    if (!m.isAvailable()) {
        recordWithdrawal(m);     // side effect before deleting
        it.remove();
    }
}

// CORRECT: classic for BACKWARDS, when you need the index
for (int i = catalog.size() - 1; i >= 0; i--) {
    if (!catalog.get(i).isAvailable()) {
        System.out.println("Withdrawal at position " + i);
        catalog.remove(i);
    }
}

// INCORRECT: ConcurrentModificationException
for (Material m : catalog) {
    if (!m.isAvailable()) { catalog.remove(m); }
}

List<Material> list = new ArrayList<>(...);

Material[] array = list.toArray(new Material[0]);    // THE CORRECT IDIOM
Object[]   bad   = list.toArray();                   // loses the type: almost never useful

Material[] array = { book1, book2, book3 };

// 1. Fixed-size VIEW backed by the array (05-01)
List<Material> view = Arrays.asList(array);
view.set(0, other);        // OK, and it modifies array[0]
// view.add(other);        // UnsupportedOperationException

// 2. MODIFIABLE and INDEPENDENT list  <- what you want almost always
List<Material> modifiable = new ArrayList<>(Arrays.asList(array));
modifiable.add(other);     // OK, and it does not touch 'array'

// 3. IMMUTABLE and independent list (Java 9+)
List<Material> immutable = List.of(array);
// immutable.set(0, other); // UnsupportedOperationException

int[] primitives = { 1, 2, 3 };
List<int[]> wrong = Arrays.asList(primitives);    // ONE list of ONE element (the whole array)
System.out.println(wrong.size());                 // 1

Integer[] boxed = { 1, 2, 3 };
List<Integer> right = Arrays.asList(boxed);       // 3 elements, as you expected
System.out.println(right.size());                 // 3

List<Integer> list = new ArrayList<>(primitives.length);
for (int n : primitives) { list.add(n); }         // autoboxing on every add

List<List<Material>> byType = new ArrayList<>();

List<Material> books = new ArrayList<>();
books.add(new Book("Effective Java", "Joshua Bloch", "978-0000000001", 2018));
books.add(new Book("Refactoring", "Martin Fowler", "978-0000000003", 1999));

List<Material> magazines = new ArrayList<>();
magazines.add(new Magazine("Java Magazine", "REV-2024-03", 42, "Monthly"));

byType.add(books);
byType.add(magazines);
byType.add(new ArrayList<>());      // the DVDs, still none of them

// Access: two indices, just as in a two-dimensional array
System.out.println(byType.get(0).get(1).getTitle());     // Refactoring

// Nested traversal
for (List<Material> group : byType) {
    System.out.println("Group of " + group.size() + " materials:");
    for (Material m : group) {
        System.out.println("   " + m.getTitle());
    }
}

List<List<String>> matrix = new ArrayList<>();
for (int i = 0; i < 3; i++) {
    matrix.add(new ArrayList<>());       // each row needs ITS OWN list
}
matrix.get(0).add("data");               // now it works

List<String> a = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));
List<String> b = new LinkedList<>(List.of("Marta Ruiz", "Diego Alonso"));
List<String> c = new ArrayList<>(List.of("Diego Alonso", "Marta Ruiz"));

System.out.println(a.equals(b));      // true  <- the implementation does NOT matter
System.out.println(a.equals(c));      // false <- the ORDER does matter
System.out.println(a.hashCode() == b.hashCode());   // true

int hash = 1;
for (E e : list) {
    hash = 31 * hash + (e == null ? 0 : e.hashCode());
}

/** Module 4's version, with Material[] and a manual counter. */
public Material[] findByType(String type) {
    Material[] result = new Material[n];         // you have to reserve the MAXIMUM possible
    int found = 0;
    for (int i = 0; i < n; i++) {                // up to n, not up to materials.length
        if (materials[i] != null && materials[i].getType().equals(type)) {
            result[found] = materials[i];
            found++;
        }
    }
    return Arrays.copyOf(result, found);         // and trim at the end
}

/** Module 5's version. */
public List<Material> findByType(String type) {
    List<Material> result = new ArrayList<>();
    for (Material m : materials) {
        if (m.getType().equals(type)) { result.add(m); }
    }
    return result;
}

public List<Material> find(Predicate<Material> criteria) {
    List<Material> result = new ArrayList<>();
    for (Material m : materials) {
        if (criteria.test(m)) { result.add(m); }
    }
    return result;
}

package com.nexussoftware.bibliotech.service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import com.nexussoftware.bibliotech.domain.Material;

/** BiblioTech's catalogue on top of ArrayList. */
public class Catalog {

    private final List<Material> materials;
    private final Set<String>    references = new HashSet<>();    // O(1) uniqueness

    public Catalog() {
        this.materials = new ArrayList<>();
    }

    /** Initial capacity: useful only when we load a large catalogue in one go. */
    public Catalog(int expectedMaterials) {
        this.materials = new ArrayList<>(Math.max(expectedMaterials, 10));
    }

    public boolean add(Material m) {
        if (m == null) { return false; }
        if (!references.add(m.getReference())) {
            return false;                             // duplicate reference
        }
        return materials.add(m);                      // always true on a List
    }

    /** Inserts at a specific position. O(n): it shifts the rest. */
    public boolean insert(int position, Material m) {
        if (m == null || position < 0 || position > materials.size()) { return false; }
        if (!references.add(m.getReference())) { return false; }
        materials.add(position, m);
        return true;
    }

    public boolean remove(String reference) {
        if (!references.remove(reference)) { return false; }
        return materials.removeIf(m -> m.getReference().equals(reference));
    }

    /** Replaces the material at a position, keeping the size. */
    public Material replace(int position, Material item) {
        Material previous = materials.set(position, item);      // returns what was there
        references.remove(previous.getReference());
        references.add(item.getReference());
        return previous;
    }

    public Material get(int position)      { return materials.get(position); }    // O(1)
    public boolean  contains(Material m)   { return materials.contains(m); }      // O(n), uses equals
    public int      indexOf(Material m)    { return materials.indexOf(m); }       // O(n)

    public List<Material> find(Predicate<Material> criteria) {
        List<Material> result = new ArrayList<>();
        for (Material m : materials) {
            if (criteria.test(m)) { result.add(m); }
        }
        return result;
    }

    public int count(Predicate<Material> criteria) {
        int n = 0;
        for (Material m : materials) {
            if (criteria.test(m)) { n++; }
        }
        return n;
    }

    public void sort(Comparator<Material> criteria) { materials.sort(criteria); }

    /** A page of results using subList, with the bounds properly controlled. */
    public List<Material> page(int pageNumber, int perPage) {
        int from = pageNumber * perPage;
        if (from >= materials.size() || from < 0) { return List.of(); }
        int to = Math.min(from + perPage, materials.size());
        return new ArrayList<>(materials.subList(from, to));     // a COPY, not a view
    }

    /** Immutable copy: nobody outside can alter the catalogue. */
    public List<Material> list()     { return List.copyOf(materials); }

    /** For when an old API asks for an array. */
    public Material[] asArray()      { return materials.toArray(new Material[0]); }

    public int     size()    { return materials.size(); }
    public boolean isEmpty() { return materials.isEmpty(); }
    public void    clear()   { materials.clear(); references.clear(); }
}

Catalog catalog = new Catalog();
catalog.add(new Book("Effective Java",  "Joshua Bloch",  "978-0000000001", 2018));
catalog.add(new Book("Design Patterns", "Erich Gamma",   "978-0000000002", 1994));
catalog.add(new Book("Refactoring",     "Martin Fowler", "978-0000000003", 1999));
catalog.add(new Magazine("Java Magazine", "REV-2024-03", 42, "Monthly"));
catalog.add(new Dvd("Refactoring Live", "DVD-0007",      95));

catalog.sort(Comparator.comparing(Material::getType)
                       .thenComparing(Material::getTitle));

System.out.println("--- Catalogue (" + catalog.size() + " materials) ---");
catalog.list().forEach(m -> System.out.println("  " + m.describe()));

List<Material> cheap = catalog.find(m -> m.getDailyRate() < 0.30);
System.out.println("Rate below 0.30 EUR/day: " + cheap.size());

System.out.println("Page 0 (2 per page):");
catalog.page(0, 2).forEach(m -> System.out.println("  " + m.getTitle()));

--- Catalogue (5 materials) ---
  [Book] Design Patterns - Erich Gamma (978-0000000002)
  [Book] Effective Java - Joshua Bloch (978-0000000001)
  [Book] Refactoring - Martin Fowler (978-0000000003)
  [DVD] Refactoring Live (DVD-0007)
  [Magazine] Java Magazine no. 42 (REV-2024-03)
Rate below 0.30 EUR/day: 4
Page 0 (2 per page):
  Design Patterns
  Effective Java

package com.nexussoftware.bibliotech.service;

import java.util.ArrayList;
import java.util.List;
import com.nexussoftware.bibliotech.domain.Loan;

public class LoanManager {

    private final List<Loan> loans = new ArrayList<>();

    public void register(Loan l) {
        if (l != null) { loans.add(l); }            // add at the end: amortised O(1)
    }

    /**
     * O(n) linear search by reference. With many loans you would have to
     * index by reference in a Map<String, Loan>: that is 05-05.
     */
    public boolean returnItem(String reference, int day) {
        if (reference == null) { return false; }
        for (Loan l : loans) {                      // for-each: we only read
            if (reference.equals(l.getReference())) {
                l.registerReturn(day);              // we modify the OBJECT, not the list: legal
                return true;
            }
        }
        return false;
    }

    public List<Loan> overdue(int currentDay) {
        List<Loan> result = new ArrayList<>();
        for (Loan l : loans) {
            if (!l.isReturned() && l.isOverdue(currentDay)) {
                result.add(l);
            }
        }
        return result;                 // an empty list if there are none, NEVER null
    }

    /**
     * removeIf makes a single O(n) pass. A loop with remove(Object)
     * would be O(n^2) and would also give ConcurrentModificationException.
     */
    public int purgeReturned() {
        int before = loans.size();
        loans.removeIf(Loan::isReturned);              // method reference (04-06)
        return before - loans.size();
    }

    public List<Loan> latest(int howMany) {
        if (howMany <= 0 || loans.isEmpty()) { return List.of(); }
        int from = Math.max(0, loans.size() - howMany);        // lower-bound protection
        // subList returns a VIEW: we copy it so that it is independent
        return new ArrayList<>(loans.subList(from, loans.size()));
    }

    public Loan oldest() {
        Loan best = null;
        for (Loan l : loans) {
            if (best == null || l.getLoanDay() < best.getLoanDay()) {
                best = l;
            }
        }
        return best;       // null if the list is empty; document it in the javadoc
    }

    public int size() { return loans.size(); }
}

package com.nexussoftware.bibliotech.presentation;

import java.util.ArrayList;
import java.util.List;

public class RemoveDemo {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(10, 20, 30, 40, 50));
        System.out.println("Initial:                    " + numbers);

        // 1) remove(int): the literal 1 is an int -> remove(int index) is chosen
        //    without autoboxing, because overloading prefers the exact match.
        numbers.remove(1);
        System.out.println("After remove(1):            " + numbers + "  <- removed POSITION 1");

        // 2) remove(Object): Integer.valueOf(30) is an Integer -> remove(Object)
        numbers.remove(Integer.valueOf(30));
        System.out.println("After remove(valueOf(30)):  " + numbers + "  <- removed VALUE 30");

        // 3) The cast has the same effect as valueOf, but it reads worse
        numbers.remove((Integer) 40);
        System.out.println("After remove((Integer) 40): " + numbers + "  <- removed VALUE 40");

        // 4) The dangerous call, commented out on purpose:
        // numbers.remove(100);
        //    -> IndexOutOfBoundsException: Index 100 out of bounds for length 2
        //    The programmer wanted to delete the VALUE 100 and asked for POSITION 100.
        //    The error shows up at run time, not at compile time.

        // 5) With String there is no ambiguity: "Marta Ruiz" is not an int,
        //    so it can only resolve as remove(Object).
        List<String> employees = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));
        employees.remove("Marta Ruiz");
        System.out.println("Employees:                  " + employees);

        // 6) A safe, reusable method
        List<Integer> ids = new ArrayList<>(List.of(101, 205, 307));
        System.out.println("removeValue(205): " + removeValue(ids, 205) + " -> " + ids);
        System.out.println("removeValue(999): " + removeValue(ids, 999) + " -> " + ids);
    }

    /**
     * Removes by VALUE with no possible ambiguity. The parameter is an int for the
     * caller's convenience, and the explicit wrapper guarantees that
     * remove(Object) is invoked and not remove(int).
     */
    public static boolean removeValue(List<Integer> list, int value) {
        return list.remove(Integer.valueOf(value));
    }
}

Initial:                    [10, 20, 30, 40, 50]
After remove(1):            [10, 30, 40, 50]  <- removed POSITION 1
After remove(valueOf(30)):  [10, 40, 50]  <- removed VALUE 30
After remove((Integer) 40): [10, 50]  <- removed VALUE 40
Employees:                  [Diego Alonso]
removeValue(205): true -> [101, 307]
removeValue(999): false -> [101, 307]

package com.nexussoftware.bibliotech.presentation;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public final class CollectionConverter {

    private CollectionConverter() { }

    public static void demoAsList() {
        System.out.println("--- Arrays.asList is a fixed-size VIEW ---");
        String[] array = { "Marta Ruiz", "Diego Alonso", "Nuria Vidal" };
        List<String> view = Arrays.asList(array);

        view.set(0, "Marta R.");                         // allowed
        System.out.println("array[0] after view.set: " + array[0]);   // Marta R.

        array[1] = "Diego A.";                            // from the other side
        System.out.println("view after array[1]=:    " + view);       // Diego A.

        // view.add("New");       -> UnsupportedOperationException: FIXED size
        // view.remove(0);        -> UnsupportedOperationException
        System.out.println("add and remove would throw UnsupportedOperationException");
    }

    public static void demoIndependentCopy() {
        System.out.println("--- new ArrayList<>(Arrays.asList(a)) is INDEPENDENT ---");
        String[] array = { "Marta Ruiz", "Diego Alonso" };
        List<String> copy = new ArrayList<>(Arrays.asList(array));

        copy.add("Nuria Vidal");         // now it is allowed
        copy.set(0, "Marta R.");

        System.out.println("copy:    " + copy);             // [Marta R., Diego Alonso, Nuria Vidal]
        System.out.println("array:   " + Arrays.toString(array));   // [Marta Ruiz, Diego Alonso]
        System.out.println("The original array has NOT been affected");
    }

    public static void demoToArray() {
        System.out.println("--- From list to array ---");
        List<String> list = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));

        // new String[0] states the TYPE. toArray internally creates one of the right size.
        String[] array = list.toArray(new String[0]);
        System.out.println("array: " + Arrays.toString(array) + " (length " + array.length + ")");

        list.add("Nuria Vidal");         // the array already generated does not change
        System.out.println("after adding to the list, array still has " + array.length);

        Object[] untyped = list.toArray();      // loses the type: almost never useful
        System.out.println("toArray() with no argument returns Object[]: " + untyped.length);
    }

    public static void demoPrimitives() {
        System.out.println("--- The primitives trap ---");
        int[] primitives = { 1, 2, 3 };
        List<int[]> wrong = Arrays.asList(primitives);
        System.out.println("Arrays.asList(int[]).size()     = " + wrong.size()
                           + "   <- ONE list of ONE element: the whole array");

        Integer[] boxed = { 1, 2, 3 };
        List<Integer> right = Arrays.asList(boxed);
        System.out.println("Arrays.asList(Integer[]).size() = " + right.size()
                           + "   <- three elements, as you expected");
        System.out.println("Cause: generics only accept reference types (10-01)");
    }

    /** The correct conversion from int[] to List<Integer>. */
    public static List<Integer> toList(int[] primitives) {
        if (primitives == null) { return List.of(); }
        // exact initial capacity: we know how many are going in
        List<Integer> list = new ArrayList<>(primitives.length);
        for (int n : primitives) {
            list.add(n);                  // autoboxing: int -> Integer on every add
        }
        return list;
    }

    public static void main(String[] args) {
        demoAsList();
        demoIndependentCopy();
        demoToArray();
        demoPrimitives();
        System.out.println("toList(new int[]{7,8,9}) = " + toList(new int[] { 7, 8, 9 }));
    }
}