Java Quick Reference

// Define a class
public class Car {
    // Fields (attributes)
    String brand;
    int    speed;

    // Constructor
    public Car(String brand, int speed) {
        this.brand = brand;
        this.speed = speed;
    }

    // Method
    public void describe() {
        System.out.println(brand + " at " + speed);
    }
}

// Create objects
Car c1 = new Car("Toyota", 120);
c1.describe(); // Toyota at 120

class Animal {
    String name;
    public void speak() { System.out.println("..."); }
}

class Dog extends Animal {
    // Override parent method
    @Override
    public void speak() { System.out.println("Woof!"); }
}

class GuideDog extends Dog {
    public void guide() {
        super.speak(); // call parent speak
        System.out.println("Leading...");
    }
}

Dog d = new Dog();
d.name = "Rex";
d.speak(); // Woof!

// Interface: defines WHAT, not HOW
interface Printable {
    void print();            // must implement
    default void preview() { // optional default
        System.out.println("preview");
    }
}

class Document implements Printable {
    public void print() { System.out.println("Printing"); }
}

// Abstract: partial implementation
abstract class Shape {
    abstract double area();  // subclass must implement
    void show() { System.out.println(area()); }
}

class Circle extends Shape {
    double r;
    double area() { return Math.PI * r * r; }
}

class Person {
    private   String name;  // only this class
    protected int    age;   // subclasses too
    public    String id;    // everyone
    // Getter/Setter for private
    public String getName() { return name; }
    public void setName(String n) { name = n; }
}

// Declare + initialize
int[] nums = {10, 20, 30, 40};
String[] names = new String[3]; // empty, size 3

// Access element: arrayName[index]
System.out.println(nums[0]);  // 10
System.out.println(nums[3]);  // 40 (last)

// Change value
nums[1] = 99;  // now {10,99,30,40}

// Length
nums.length   // 4 (property, not method!)

// Loop through
for (int n : nums) System.out.println(n);

// Sort
Arrays.sort(nums);  // {10,30,40,99}

// Declare 2D array [rows][cols]
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Access: matrix[row][col]
matrix[0][0]  // 1 (top-left)
matrix[1][2]  // 6
matrix[2][2]  // 9 (bottom-right)

// Change value
matrix[0][1] = 99;

// Loop through 2D
for (int[] row : matrix) {
    for (int val : row) {
        System.out.print(val + " ");
    }
    System.out.println();
}

import java.util.Arrays;

int[] a = {5,2,8,1};

Arrays.sort(a);              // [1,2,5,8]
Arrays.toString(a);          // "[1, 2, 5, 8]"
Arrays.fill(a, 0);           // [0,0,0,0]
Arrays.copyOf(a, 2);         // [0,0] first 2
Arrays.copyOfRange(a,1,3);   // index 1 to 2
Arrays.binarySearch(a, 5);  // index (sort first!)
Arrays.equals(a, b);         // compare two arrays

// Convert array to List
List<Integer> list = Arrays.asList(1,2,3);

try {
    int result = 10 / 0;      // throws!
} catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
} catch (Exception e) {       // catch-all
    e.printStackTrace();
} finally {
    System.out.println("Always runs!");
    // close resources here
}

// Multi-catch (Java 7+)
catch (IOException | SQLException e) { ... }

// Try-with-resources (auto-close)
try (FileReader fr = new FileReader("f.txt")) {
    // fr auto-closed when done
}

// throws declaration
public void setAge(int age) throws Exception {
    if (age < 0) throw new Exception("Bad age");
    this.age = age;
}

// Custom exception
class InvalidAgeException extends RuntimeException {
    public InvalidAgeException(String msg) {
        super(msg);
    }
}
// Use it
throw new InvalidAgeException("Age must be >= 0");

// Common exceptions to know:
// NullPointerException, ArrayIndexOutOfBoundsException
// ClassCastException, NumberFormatException
// StackOverflowError, OutOfMemoryError

// Old way (anonymous class)
Runnable r = new Runnable() {
    public void run() { System.out.println("Hi"); }
};

// Lambda way: (params) -> body
Runnable r2 = () -> System.out.println("Hi");

// With parameters
Comparator<Integer> cmp = (a, b) -> a - b;

// Method reference (even shorter)
list.forEach(System.out::println);

List<Integer> nums = List.of(1,2,3,4,5,6);

// filter → map → collect
List<Integer> evens = nums.stream()
    .filter(n -> n % 2 == 0)  // keep even
    .map(n -> n * 10)          // multiply
    .collect(Collectors.toList());
// [20, 40, 60]

// reduce → single value
int sum = nums.stream().reduce(0, Integer::sum);

// sorted, distinct, count
nums.stream().sorted().distinct().count();

// anyMatch, allMatch, noneMatch
nums.stream().anyMatch(n -> n > 4); // true

// findFirst
nums.stream().filter(n->n>3).findFirst(); // Optional[4]

// Wrap value that might be null
Optional<String> opt = Optional.of("Hello");
Optional<String> empty = Optional.empty();

opt.isPresent();          // true
opt.get();                // "Hello"
opt.orElse("default");   // value or default
opt.orElseGet(() -> ...); // lazy default
opt.map(String::toUpperCase); // transform
opt.ifPresent(s -> System.out.println(s));

// Predicate: T → boolean
Predicate<String> notEmpty = s -> !s.isEmpty();

// Function: T → R
Function<String, Integer> len = s -> s.length();

// Consumer: T → void
Consumer<String> print = System.out::println;

// Supplier: () → T
Supplier<String> hello = () -> "Hello!";

// BiFunction: (T,U) → R
BiFunction<Integer,Integer,Integer> add = (a,b) -> a+b;

import java.io.File;

File f = new File("notes.txt");

// Create new file
f.createNewFile();       // returns true if created

// Check info
f.exists();              // true / false
f.getName();             // "notes.txt"
f.getAbsolutePath();     // full path
f.length();              // size in bytes
f.isFile();              // true
f.isDirectory();         // false
f.canRead();             // true/false
f.canWrite();            // true/false

// Delete
f.delete();

// Create directory
File dir = new File("myFolder");
dir.mkdir();             // one level
dir.mkdirs();            // nested dirs

// List all files in folder
String[] files = dir.list();
File[]   fileObjs = dir.listFiles();

import java.io.*;

// FileWriter — basic write (overwrites!)
FileWriter fw = new FileWriter("notes.txt");
fw.write("Hello World\n");
fw.close(); // ALWAYS close!

// Append mode (add without overwriting)
FileWriter fw2 = new FileWriter("notes.txt", true);
fw2.write("New line\n");
fw2.close();

// BufferedWriter — faster for large writes
BufferedWriter bw = new BufferedWriter(
    new FileWriter("notes.txt"));
bw.write("Line 1");
bw.newLine(); // platform-safe newline
bw.write("Line 2");
bw.close();

// PrintWriter — easiest println style
PrintWriter pw = new PrintWriter("notes.txt");
pw.println("Hello");
pw.printf("Name: %s, Age: %d\n", "Ravi", 25);
pw.close();

import java.io.*;
import java.util.Scanner;

// Scanner — easiest way to read
File f = new File("notes.txt");
Scanner sc = new Scanner(f);
while (sc.hasNextLine()) {
    String line = sc.nextLine();
    System.out.println(line);
}
sc.close();

// BufferedReader — faster for big files
BufferedReader br = new BufferedReader(
    new FileReader("notes.txt"));
String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}
br.close();

// try-with-resources (auto-closes!)
try (BufferedReader r = new BufferedReader(
        new FileReader("notes.txt"))) {
    r.lines().forEach(System.out::println);
} // auto-closed here!

import java.nio.file.*;
import java.util.List;

Path p = Paths.get("notes.txt");

// Write (creates or overwrites)
Files.write(p, "Hello".getBytes());

// Write lines
List<String> lines = List.of("Line 1","Line 2");
Files.write(p, lines);

// Read all content as String
String content = Files.readString(p);

// Read all lines into List
List<String> all = Files.readAllLines(p);

// Copy / Move / Delete
Files.copy(p, Paths.get("backup.txt"));
Files.move(p, Paths.get("renamed.txt"));
Files.delete(p);

// Check
Files.exists(p);
Files.size(p);          // bytes
Files.isDirectory(p);

import java.io.*;

// Write bytes
FileOutputStream fos = new FileOutputStream("img.dat");
byte[] data = {65, 66, 67}; // A, B, C
fos.write(data);
fos.close();

// Read bytes
FileInputStream fis = new FileInputStream("img.dat");
int b;
while ((b = fis.read()) != -1) {
    System.out.print((char) b); // ABC
}
fis.close();

// Buffered byte streams (faster)
BufferedInputStream  bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);

import java.util.Scanner;

Scanner sc = new Scanner(System.in);

// Read a String (one word)
System.out.print("Enter name: ");
String name = sc.next();

// Read full line (with spaces)
System.out.print("Enter sentence: ");
String line = sc.nextLine();

// Read integer
System.out.print("Enter age: ");
int age = sc.nextInt();

// Read double
double price = sc.nextDouble();

// Read boolean
boolean flag = sc.nextBoolean(); // "true"/"false"

sc.close(); // good practice

// BUG: nextInt() leaves newline in buffer!
int age = sc.nextInt();
sc.nextLine(); // consume leftover newline
String name = sc.nextLine(); // now works!

// Multiple inputs on one line
// User types: "25 3.14 true"
int     a = sc.nextInt();
double  b = sc.nextDouble();
boolean c = sc.nextBoolean();

// Check before reading
if (sc.hasNextInt()) {
    int n = sc.nextInt();
}

// Loop until valid input
while (!sc.hasNextInt()) {
    System.out.println("Enter a number!");
    sc.next(); // discard bad input
}
int num = sc.nextInt();

import java.time.*;

// Current date / time
LocalDate     date  = LocalDate.now();      // 2026-03-25
LocalTime     time  = LocalTime.now();      // 14:30:05
LocalDateTime both  = LocalDateTime.now(); // 2026-03-25T14:30

// Specific date/time
LocalDate d = LocalDate.of(2000, 12, 25);
LocalTime t = LocalTime.of(9, 30, 0);

// Get parts
date.getYear();        // 2026
date.getMonth();       // MARCH
date.getMonthValue(); // 3
date.getDayOfMonth(); // 25
date.getDayOfWeek();  // WEDNESDAY

// Add / subtract
date.plusDays(7);
date.minusMonths(2);
date.plusYears(1);

import java.time.*;
import java.time.format.DateTimeFormatter;

LocalDateTime now = LocalDateTime.now();

// Predefined formats
now.format(DateTimeFormatter.ISO_LOCAL_DATE);
// "2026-03-25"

// Custom format
DateTimeFormatter fmt =
    DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm");
String formatted = now.format(fmt);
// "25/03/2026 14:30"

// Parse string → LocalDate
LocalDate parsed = LocalDate.parse(
    "25/03/2026",
    DateTimeFormatter.ofPattern("dd/MM/yyyy")
);

// Format patterns:
// yyyy=year  MM=month  dd=day
// HH=hour(24) hh=hour(12) mm=min ss=sec
// E=day name  MMMM=full month name

LocalDate d1 = LocalDate.of(2000, 1, 1);
LocalDate d2 = LocalDate.now();

// Period = date difference (years/months/days)
Period p = Period.between(d1, d2);
p.getYears();   // 26
p.getMonths();  // 2
p.getDays();    // 24

// Duration = time difference (hours/mins/secs)
LocalTime t1 = LocalTime.of(9,0);
LocalTime t2 = LocalTime.of(17,30);
Duration dur = Duration.between(t1, t2);
dur.toHours();   // 8
dur.toMinutes(); // 510

// Compare dates
d2.isAfter(d1);     // true
d2.isBefore(d1);    // false
d1.isEqual(d2);     // false
d2.compareTo(d1);   // positive

// Autoboxing: primitive → Wrapper (auto)
Integer i = 42;       // int → Integer
Double  d = 3.14;    // double → Double
Boolean b = true;    // boolean → Boolean

// Unboxing: Wrapper → primitive (auto)
int    n = i;         // Integer → int
double x = d;        // Double → double

// Use in ArrayList (needs objects)
ArrayList<Integer> list = new ArrayList<>();
list.add(10);  // auto-boxed to Integer
int val = list.get(0); // auto-unboxed to int

// Integer utilities
Integer.parseInt("42");       // String → int
Integer.toString(42);         // int → String
Integer.toBinaryString(10);   // "1010"
Integer.toHexString(255);     // "ff"
Integer.toOctalString(8);     // "10"
Integer.MAX_VALUE;               // 2147483647
Integer.MIN_VALUE;               // -2147483648
Integer.max(5, 10);            // 10
Integer.min(5, 10);            // 5
Integer.sum(5, 10);            // 15

// Double utilities
Double.parseDouble("3.14");
Double.isNaN(0.0/0.0);          // true
Double.isInfinite(1.0/0.0);    // true

// Character utilities
Character.isLetter('A');    // true
Character.isDigit('5');     // true
Character.toUpperCase('a');// 'A'
Character.isWhitespace(' ');

// Generic class: works with any type
class Box<T> {
    private T value;
    public Box(T val) { this.value = val; }
    public T get() { return value; }
}

// Use with Integer
Box<Integer> intBox = new Box<>(42);
intBox.get(); // 42 (int)

// Use with String
Box<String> strBox = new Box<>("Hello");
strBox.get(); // "Hello" (String)

// Multiple type params
class Pair<K, V> {
    K key; V value;
    public Pair(K k, V v) { key=k; value=v; }
}

// Generic method
public static <T> void printArray(T[] arr) {
    for (T item : arr) System.out.println(item);
}

// Call with any type
printArray(new Integer[]{1,2,3});
printArray(new String[]{"a","b"});

// Bounded type: T must be Number or subclass
public static <T extends Number> double sum(T a, T b) {
    return a.doubleValue() + b.doubleValue();
}

// Wildcard ? = unknown type
public static void printList(List<?> list) {
    for (Object o : list) System.out.println(o);
}

// Upper bounded: List of Number or subclass
List<? extends Number> nums;
// Lower bounded: List of Number or superclass
List<? super Integer> ints;

// Define enum
enum Day {
    MON, TUE, WED, THU, FRI, SAT, SUN
}

// Declare variable
Day today = Day.WED;

// Use in if
if (today == Day.WED) {
    System.out.println("Wednesday!");
}

// Use in switch
switch (today) {
    case SAT: case SUN:
        System.out.println("Weekend!"); break;
    default:
        System.out.println("Weekday");
}

// Loop all values
for (Day d : Day.values()) {
    System.out.println(d);
}

// Enum with fields and methods
enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS  (4.869e+24, 6.0518e6),
    EARTH  (5.976e+24, 6.37814e6);

    private final double mass;
    private final double radius;

    Planet(double mass, double radius) {
        this.mass = mass; this.radius = radius;
    }

    double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }
}

// Built-in enum methods
String name = Day.MON.name();    // "MON"
int    pos  = Day.MON.ordinal(); // 0 (index)
Day    d    = Day.valueOf("MON");// Day.MON
Day[]  all  = Day.values();       // all values

// Way 1: extend Thread
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running!");
    }
}
MyThread t = new MyThread();
t.start(); // start() not run()!

// Way 2: implement Runnable (preferred)
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable!");
    }
}
Thread t2 = new Thread(new MyRunnable());
t2.start();

// Way 3: Lambda (simplest)
Thread t3 = new Thread(() -> {
    System.out.println("Lambda thread!");
});
t3.start();

Thread t = new Thread(() -> { /* ... */ });

t.start();             // begin execution
t.setName("Worker"); // give a name
t.getName();          // get name
t.setPriority(10);   // 1(low) to 10(high)
t.getPriority();      // default 5
t.isAlive();           // is still running?
t.join();              // wait for it to finish
t.interrupt();         // request stop

// Sleep (pause this thread)
try {
    Thread.sleep(1000); // sleep 1 second
} catch (InterruptedException e) { ... }

// Current thread info
Thread.currentThread().getName();
Thread.currentThread().getId();

// Thread states
// NEW → RUNNABLE → RUNNING → BLOCKED/WAITING → TERMINATED

class Counter {
    private int count = 0;

    // synchronized method
    public synchronized void increment() {
        count++;
    }

    // synchronized block (more fine-grained)
    public void add(int n) {
        synchronized(this) {
            count += n;
        }
    }
    public int getCount() { return count; }
}

// volatile: ensures visibility across threads
private volatile boolean running = true;

import java.util.concurrent.*;

// Fixed thread pool (e.g. 3 threads)
ExecutorService exec =
    Executors.newFixedThreadPool(3);

// Submit tasks
exec.execute(() -> System.out.println("Task 1"));
exec.execute(() -> System.out.println("Task 2"));

// Submit with result (Future)
Future<Integer> future = exec.submit(() -> {
    Thread.sleep(100);
    return 42;
});
int result = future.get(); // blocks until done

// Shutdown (no new tasks)
exec.shutdown();
// Types: newCachedThreadPool(), newSingleThreadExecutor()

import java.util.regex.*;

// Simple: String.matches()
"Hello123".matches("[A-Za-z0-9]+"); // true

// Pattern + Matcher
Pattern p = Pattern.compile("\\d+"); // one+ digits
Matcher m = p.matcher("I have 3 cats and 12 dogs");

while (m.find()) {
    System.out.println(m.group()); // "3", "12"
}

// matches() — whole string must match
m.reset();
boolean exact = m.matches();

// find() — find anywhere in string
// group() — get matched text
// start() — match start index
// end()   — match end index

String s = "Hello   World  Java";

// replaceAll: replace pattern
s.replaceAll("\\s+", " ");   // "Hello World Java"
s.replaceFirst("\\d", "X"); // first digit→X

// split: split by pattern
String[] words = s.split("\\s+"); // by spaces
// ["Hello", "World", "Java"]

// Common patterns for validation
String email = "user@example.com";
boolean validEmail = email.matches(
    "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");

String phone = "9876543210";
boolean validPhone = phone.matches("[6-9]\\d{9}");

String zip = "440001";
boolean validZip = zip.matches("\\d{6}");

import java.util.*;

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

// Get iterator
Iterator<String> it = list.iterator();

// Loop: hasNext() → next()
while (it.hasNext()) {
    String s = it.next();
    if (s.equals("B")) {
        it.remove(); // SAFE remove during iteration!
    }
}
// list: ["A", "C", "D"]

// ListIterator — can go backward too
ListIterator<String> li = list.listIterator();
while (li.hasNext())    { li.next(); }
while (li.hasPrevious()){ li.previous(); }

// Map iterator
Iterator<Map.Entry<String,Integer>> mi =
    map.entrySet().iterator();

List<Integer> nums = new ArrayList<>(List.of(3,1,4,2));

// Natural sort (ascending)
Collections.sort(nums);          // [1,2,3,4]

// Reverse sort
Collections.sort(nums, Collections.reverseOrder());

// Lambda comparator
nums.sort((a, b) -> b - a);   // descending

// Sort strings by length
List<String> words = new ArrayList<>(List.of("banana","fig","apple"));
words.sort(Comparator.comparingInt(String::length));
// [fig, apple, banana]

// Custom object sort (Comparator)
List<Person> people = ...;
people.sort(Comparator.comparing(p -> p.name));
// or multi-level sort
people.sort(Comparator.comparing(Person::getName)
    .thenComparing(Person::getAge));

// Implement Comparable to make class sortable
class Student implements Comparable<Student> {
    String name;
    int    grade;

    @Override
    public int compareTo(Student other) {
        return this.grade - other.grade; // asc grade
        // return other.grade - this.grade; // desc
        // return this.name.compareTo(other.name); // alpha
    }
}

// Now can use Collections.sort() directly
List<Student> students = ...;
Collections.sort(students); // uses compareTo
TreeSet<Student> ts = new TreeSet<>(students); // works!

// Rounding
Math.round(3.7)      // 4
Math.floor(3.9)      // 3.0 (round down)
Math.ceil(3.1)       // 4.0 (round up)

// Power / root
Math.pow(2, 10)     // 1024.0
Math.sqrt(144)      // 12.0
Math.cbrt(27)       // 3.0 (cube root)

// Min / Max / Abs
Math.max(10, 20)    // 20
Math.min(10, 20)    // 10
Math.abs(-99)       // 99

// Logs
Math.log(10)        // natural log
Math.log10(1000)   // 3.0

// Trig (radians)
Math.sin(Math.PI/2)  // 1.0
Math.cos(0)           // 1.0
Math.PI                 // 3.14159...
Math.E                  // 2.71828...

// Random number [0.0, 1.0)
Math.random()         // 0.0 to 0.999
// Random int 0-99:
(int)(Math.random() * 100)

StringBuilder sb = new StringBuilder();

sb.append("Hello");
sb.append(" ");
sb.append("World");

sb.insert(5, ",");       // insert at index
sb.delete(0, 5);        // delete range
sb.replace(0, 5, "Hi");// replace range
sb.reverse();           // reverse it
sb.length();            // length
sb.charAt(0);           // char at index
sb.indexOf("World");   // find substring
sb.toString();          // convert to String

// Good pattern for building strings in loops
StringBuilder result = new StringBuilder();
for (int i = 0; i < 100; i++) {
    result.append(i).append(",");
}
String s = result.toString();

import java.util.Collections;

List<Integer> list = new ArrayList<>(List.of(3,1,4,1,5));

Collections.sort(list);          // [1,1,3,4,5]
Collections.reverse(list);       // [5,4,3,1,1]
Collections.shuffle(list);       // random order
Collections.min(list);           // 1
Collections.max(list);           // 5
Collections.frequency(list, 1); // 2 (count of 1s)
Collections.fill(list, 0);      // all zeros
Collections.nCopies(5, "x");   // [x,x,x,x,x]
Collections.swap(list, 0, 4);  // swap index 0↔4
Collections.disjoint(listA,listB); // no common?

// Unmodifiable wrappers
List<Integer> locked = Collections.unmodifiableList(list);
Map<String,Integer> lockedMap = Collections.unmodifiableMap(map);

// Synchronized wrappers (thread-safe)
List<Integer> synced = Collections.synchronizedList(list);

// Built-in annotations
@Override         // must match parent method
@Deprecated       // warns: don't use this
@SuppressWarnings("unchecked") // suppress warning
@FunctionalInterface // must have exactly one abstract method

// Example usage
class Animal {
    @Deprecated
    public void oldSound() { }

    public void sound() { }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Woof");
    }
}

// Custom annotation
public @interface MyAnnotation {
    String value() default "default";
}

// Binary search (list must be sorted first!)
List<Integer> sorted = List.of(1,3,5,7,9);
int idx = Collections.binarySearch(sorted, 5); // 2

// Arrays binary search
int[] arr = {1,3,5,7,9};
Arrays.binarySearch(arr, 7); // 3

// Streams sorting
List<Integer> asc = nums.stream()
    .sorted().collect(Collectors.toList());
List<Integer> desc = nums.stream()
    .sorted(Comparator.reverseOrder())
    .collect(Collectors.toList());

// Group by (very powerful!)
Map<Integer, List<String>> byLen = words.stream()
    .collect(Collectors.groupingBy(String::length));

// Count by condition
long count = nums.stream().filter(n -> n > 5).count();

// Old way: 20+ lines of boilerplate
// New way with record: 1 line!
record Point(int x, int y) {}

Point p = new Point(3, 4);
p.x();           // 3 (accessor method)
p.y();           // 4
p.toString();    // "Point[x=3, y=4]"

// With custom constructor
record Person(String name, int age) {
    // Compact constructor (validation)
    Person {
        if (age < 0) throw new IllegalArgumentException();
    }
    // Custom method
    boolean isAdult() { return age >= 18; }
}