Collections, Generics and Iteration

Starter: think before typing

Before running this data structures example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Programming 1 = 20 credits Programming 2 = 0 credits`; predict how the focus line helps produce that evidence.

Learning Objectives

• Choose arrays or collections appropriately.
• Use generic types to reduce casting errors.
• Iterate over collections safely.
• Use maps for key-value lookup.

Learning Outcomes

• By the end of the lesson, you can choose arrays or collections appropriately.
• By the end of the lesson, you can use generic types to reduce casting errors.
• By the end of the lesson, you can iterate over collections safely.
• By the end of the lesson, you can use maps for key-value lookup.

Why this idea exists

Collections are reusable answers to common data-structure problems: storing ordered items, looking up values by key, avoiding duplicates and traversing groups of objects.

Generics were added to Java to make collections safer and clearer. Before generics, programmers often had to cast values out of collections, which moved type mistakes from early checking into later failures.

Choosing a collection is a design decision. An `ArrayList` suggests ordered traversal, a `HashMap` suggests keyed lookup, and each choice communicates assumptions about how the data will be used.

Deep dive

Lesson visual

Type this and run it

Create CollectionsGenericsIterationDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CollectionsGenericsIterationDemo {
  public static void main(String[] args) {
    List<String> modules = new ArrayList<>();
    modules.add("Programming 1");
    modules.add("Programming 2");
    Map<String, Integer> credits = new HashMap<>();
    credits.put("Programming 1", 20);
    for (String module : modules) {
      System.out.println(module + " = " + credits.getOrDefault(module, 0) + " credits");
    }
  }
}

Build and run it with:

javac CollectionsGenericsIterationDemo.java && java CollectionsGenericsIterationDemo

Expected baseline: Programming 1 = 20 credits Programming 2 = 0 credits

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is credits.put("Programming 1", 20);; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in collections, generics and iteration is treating the example as a finished answer. For data structures, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

How to study this lesson

For Collections, Generics and Iteration, predict how data structures changes the run before you press Run.

Use the first portfolio task as your main edit: Replace an array with an ArrayList.

Use the second task as your variation: Use a HashMap for module credits.

Finish with evidence, not a diary entry: Explain what generics prevent.

Portfolio Practice

1. Replace an array with an ArrayList.
2. Use a HashMap for module credits.
3. Explain what generics prevent.

Final self-check

Study route

Practise data structures by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Time, Space and Speed Trade-offs and carry forward one improvement from this lesson into the next program.