Primitive Types

Operators & Assignment

• Arithmetic: + - * / % — integer / truncates, % gives remainder
• Compound: += -= *= /= %= and ++ --
• Casting: (int) 3.9 → 3 (truncates, does NOT round); (double) 5 → 5.0
• Integer overflow: exceeding Integer.MAX_VALUE wraps to negative

Objects & Methods

• Reference types store memory addresses (Strings, objects)
• Create objects: ClassName obj = new ClassName(args);
• Void methods perform action, return nothing
• Return methods give back a value you must use or store
• Method signature: name + parameter list (types and order matter)

String Methods (on Quick Reference)

Wrapper Classes & Math

• Integer, Double — needed for ArrayList; autoboxing converts automatically
• Integer.parseInt(str) and Double.parseDouble(str) convert Strings to numbers (on Quick Ref)
• Integer.MIN_VALUE / Integer.MAX_VALUE — useful for initializing min/max searches
• Math.abs(x), Math.pow(base, exp), Math.sqrt(x)
• Math.random() returns [0.0, 1.0) — includes 0.0, excludes 1.0
• Random int in range: (int)(Math.random() * range) + min

// Random int from 1 to 6 (inclusive)
int roll = (int)(Math.random() * 6) + 1;

Boolean Expressions & Conditionals

• Relational: < > <= >= == !=
• Logical: && (AND) || (OR) ! (NOT)
• Short-circuit: && stops on first false; || stops on first true
• De Morgan’s Laws:

// These pairs are equivalent:
!(a && b)  ↔  !a || !b
!(a || b)  ↔  !a && !b

• if / if-else / else if: only one branch executes in a chain
• Dangling else: an else pairs with the nearest unmatched if

Loops

Essential Loop Patterns

// Accumulator (sum)
int sum = 0;
for (int val : arr) {
    sum += val;
}

// Counter (count matches)
int count = 0;
for (int val : arr) {
    if (val > 0) {
        count++;
    }
}

// Find max
int max = arr[0];
for (int val : arr) {
    if (val > max) {
        max = val;
    }
}

String Traversal

for (int i = 0; i < str.length(); i++) {
    String ch = str.substring(i, i + 1);
    // process each character
}

Nested Loops

• Outer loop runs m times, inner runs n times → body executes m × n times
• Used for: 2D traversal, pattern printing, comparing all pairs

Class Anatomy

public class Player {
    private String name;
    private int score;

    public Player(String name, int score) {
        this.name = name;
        this.score = score;
    }

    // Accessor (getter)
    public String getName() {
        return name;
    }

    // Mutator (setter)
    public void addPoints(int pts) {
        score += pts;
    }

    // toString (on Quick Reference)
    public String toString() {
        return name + ": " + score;
    }
}

Key Concepts

• Encapsulation: private instance variables + public getters/setters
• this: refers to the current object; disambiguates parameter vs. instance variable
• Constructor overloading: multiple constructors with different parameter lists
• Static members: belong to the class, not any instance. Called via ClassName.method()
• Static methods cannot access instance variables (no this)
• Scope: local variables exist only inside their method/block
• toString(): called automatically when object is printed or concatenated with a String
• equals(Object other): override to compare object content, not references

Arrays

• Declaration: int[] arr = new int[5]; or int[] arr = {1, 2, 3};
• Fixed size — cannot grow or shrink after creation
• Index: 0 to arr.length - 1 (note: .length has NO parentheses)
• Default values: 0 for int, 0.0 for double, false for boolean, null for objects

ArrayList

• Wrapper types only: ArrayList, not ArrayList
• size() with parentheses vs. arr.length without

for (int i = list.size() - 1; i >= 0; i--) {
    if (list.get(i) < 0) {
        list.remove(i);
    }
}

Searching & Sorting

2D Arrays

int[][] grid = new int[3][4]; // 3 rows, 4 cols
grid.length      // number of rows (3)
grid[0].length   // number of cols (4)

// Row-major traversal (standard)
for (int r = 0; r < grid.length; r++)
    for (int c = 0; c < grid[0].length; c++)
        // process grid[r][c]

// Column-major traversal
for (int c = 0; c < grid[0].length; c++)
    for (int r = 0; r < grid.length; r++)
        // process grid[r][c]

File & Scanner (NEW for 2025–2026)

These classes are new to the exam and appear on the Quick Reference.

// Reading a file line by line
Scanner input = new Scanner(new File("data.txt"));
while (input.hasNext()) {
    String line = input.nextLine();
    // process line
}
input.close();

Recursion Tracing (NEW for 2025–2026)

You will NOT write recursive methods — only trace them.

// Trace: what does mystery(4) return?
public static int mystery(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * mystery(n - 1);
}
// mystery(4) → 4*mystery(3) → 4*3*mystery(2) → 4*3*2*mystery(1) → 24