int a = 7;
double b = (double) a / 2;  // b = 3.5  (cast BEFORE division)
int c = (int) 3.9;           // c = 3    (truncates, does NOT round)
int d = (int) (3.9 + 0.5);  // c = 4    (manual round trick)

String s = "HelloWorld";

s.length()              // 10
s.substring(0, 5)      // "Hello"   (index 0,1,2,3,4 — stops BEFORE 5)
s.substring(5)         // "World"   (from index 5 to end)
s.indexOf("World")     // 5
s.indexOf("xyz")       // -1  (not found)
s.equals("HelloWorld") // true
s.compareTo("Hello")   // positive  ("HelloWorld" > "Hello")
s.compareTo("Helloz")  // negative  ('W' < 'z' in Unicode)

// charAt — NOT on quick ref but commonly tested:
s.charAt(0)            // 'H'  (char, not String)

// Random int from 0 to n-1 (n possibilities):
(int)(Math.random() * n)

// Random int from 1 to n (inclusive):
(int)(Math.random() * n) + 1

// Random int from low to high (inclusive):
(int)(Math.random() * (high - low + 1)) + low

// Examples:
(int)(Math.random() * 6) + 1   // 1 to 6  (simulates die roll)
(int)(Math.random() * 100)       // 0 to 99
(int)(Math.random() * 100) + 1  // 1 to 100

Math.abs(-7)         // 7
Math.pow(2, 10)      // 1024.0  (always returns double)
Math.sqrt(16)        // 4.0     (always returns double)
(int) Math.pow(2,3)  // 8       (cast to int when needed)

// Autoboxing: int -> Integer (automatic)
ArrayList<Integer> nums = new ArrayList<>();
nums.add(42);           // 42 autoboxed to Integer

// Unboxing: Integer -> int (automatic)
int x = nums.get(0);    // Integer unboxed to int

// Finding max using Integer.MIN_VALUE
int max = Integer.MIN_VALUE;
for (int val : nums) {
    if (val > max) max = val;
}

import java.util.Scanner;
import java.io.File;

// File contents:
// 5
// 10 20 30 40 50

Scanner sc = new Scanner(new File("numbers.txt"));

int count = sc.nextInt();          // read the count from line 1: 5
int[] data = new int[count];      // allocate array of that size

for (int i = 0; i < data.length; i++) {
    data[i] = sc.nextInt();        // read each int directly into array
}

sc.close();
// data = {10, 20, 30, 40, 50}

import java.util.Scanner;
import java.util.ArrayList;
import java.io.File;

// File contents: one int per line, unknown count
// 42
// 17
// 99
// 5

Scanner sc = new Scanner(new File("scores.txt"));
ArrayList<Integer> scores = new ArrayList<>();

while (sc.hasNextInt()) {
    scores.add(sc.nextInt());      // autoboxes int to Integer
}

sc.close();
// scores = [42, 17, 99, 5]  -- size grew automatically

import java.util.Scanner;
import java.io.File;

// File contents: name score per line
// Alice 95
// Bob 87
// Carol 91

Scanner sc = new Scanner(new File("grades.txt"));
ArrayList<Integer> gradeList = new ArrayList<>();

while (sc.hasNext()) {
    String name  = sc.next();              // reads "Alice", "Bob", etc.
    String token = sc.next();              // reads "95", "87", etc. as String
    int grade = Integer.parseInt(token);  // converts String "95" -> int 95
    gradeList.add(grade);
}

sc.close();
// gradeList = [95, 87, 91]

import java.util.Scanner;
import java.io.File;

// File contents:
// Hello World
// AP Computer Science A
// Java is great

Scanner sc = new Scanner(new File("lines.txt"));
ArrayList<String> lines = new ArrayList<>();

while (sc.hasNext()) {
    lines.add(sc.nextLine());      // each full line as one String
}

sc.close();
// lines = ["Hello World", "AP Computer Science A", "Java is great"]

Scanner sc = new Scanner(new File("data.txt"));
int count = sc.nextInt();     // reads the int...
sc.nextLine();                // ...consume leftover newline <-- FIX
String line = sc.nextLine(); // now reads the actual next line correctly

// Declare and allocate (default values: 0, 0.0, false, null)
int[] scores = new int[5];

// Declare with initializer list
int[] primes = {2, 3, 5, 7, 11};

// Access and modify
primes[0] = 2;           // first element
primes[primes.length-1]  // last element (length-1, not length!)

int[] arr = {10, 20, 30, 40, 50};

// Standard for loop (use when you need index)
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// Enhanced for loop (read-only, clean)
for (int val : arr) {
    System.out.println(val);
}

// Common algorithms
int sum = 0;
int max = arr[0];           // initialize to first element, not 0
for (int val : arr) {
    sum += val;
    if (val > max) max = val;
}

import java.util.ArrayList;

ArrayList<Integer> list = new ArrayList<>();
list.add(10);             // [10]
list.add(20);             // [10, 20]
list.add(30);             // [10, 20, 30]
list.add(1, 15);          // [10, 15, 20, 30]  (inserts at index 1)

list.size()               // 4
list.get(0)               // 10
list.set(0, 99)           // returns 10, list is now [99, 15, 20, 30]
list.remove(1)            // returns 15, list is now [99, 20, 30]

// Safe removal while traversing: iterate BACKWARD
for (int i = list.size() - 1; i >= 0; i--) {
    if (list.get(i) < 0) {
        list.remove(i);    // safe: only affects indices after i
    }
}

// Enhanced for loop (read-only — do NOT modify during this)
for (Integer val : list) {
    System.out.println(val);
}

// Declaration and allocation (3 rows, 4 columns)
int[][] grid = new int[3][4];

// Initializer list
int[][] matrix = {{1,2,3},
                   {4,5,6},
                   {7,8,9}};

// Dimensions
grid.length         // number of rows (3)
grid[0].length      // number of columns (4)

// Row-major traversal (outer=row, inner=col) — most common
for (int r = 0; r < matrix.length; r++) {
    for (int c = 0; c < matrix[r].length; c++) {
        System.out.print(matrix[r][c] + " ");
    }
    System.out.println();
}

// Enhanced for loop version
for (int[] row : matrix) {
    for (int val : row) {
        System.out.print(val + " ");
    }
}

public class ClassName {

    // Instance variables (always private)
    private String name;
    private int value;

    // Constructor (same name as class, no return type)
    public ClassName(String name, int value) {
        this.name = name;       // this.x = parameter x
        this.value = value;
    }

    // Accessor (getter) — returns value, no modification
    public String getName() {
        return name;
    }

    // Mutator (setter) — modifies value, returns void
    public void setValue(int newValue) {
        value = newValue;
    }

    // toString — override for readable output
    public String toString() {
        return "ClassName[" + name + ", " + value + "]";
    }
}