Java on Software Engineering Learning Paths

Java: JVM Architecture

Mon, 01 Jan 0001 00:00:00 +0000

From Source to Execution#

flowchart LR
 A["Hello.java"] -->|"javac"| B["Hello.class<br>(bytecode)"]
 B -->|"java"| C["Class Loader"]
 C --> D["Bytecode Verifier"]
 D --> E["Interpreter"]
 D --> F["JIT Compiler"]
 E --> G["Native Execution"]
 F --> G

Compilation vs Interpretation#

Java uses a two-stage execution model:

Ahead-of-time (AOT): javac compiles .java → .class (bytecode)
Just-in-time (JIT): The JVM compiles hot bytecode → native machine code at runtime

# Compile
javac Hello.java # Produces Hello.class

# Run
java Hello # JVM loads, verifies, interprets/JIT-compiles

# Inspect bytecode
javap -c Hello.class # Disassemble bytecode

// Hello.java
public class Hello {
 public static void main(String[] args) {
 System.out.println("Hello, JVM!");
 }
}

Disassembled bytecode:

Java: Syntax, Types, and Operators

Mon, 01 Jan 0001 00:00:00 +0000

Primitive Types#

Java has 8 primitive types — they live on the stack, not the heap.

Type	Size	Range	Default	Wrapper
`byte`	8 bits	-128 to 127	0	`Byte`
`short`	16 bits	-32,768 to 32,767	0	`Short`
`int`	32 bits	-2³¹ to 2³¹-1	0	`Integer`
`long`	64 bits	-2⁶³ to 2⁶³-1	0L	`Long`
`float`	32 bits	±3.4×10³⁸	0.0f	`Float`
`double`	64 bits	±1.7×10³⁰⁸	0.0d	`Double`
`char`	16 bits	0 to 65,535 (Unicode)	‘\u0000’	`Character`
`boolean`	JVM-specific	true/false	false	`Boolean`

// Literals
int decimal = 42;
int hex = 0x2A; // 42 in hex
int binary = 0b101010; // 42 in binary
long big = 10_000_000L; // Underscores for readability
double pi = 3.14159;
float f = 3.14f; // Must suffix with f
char c = 'A';
char unicode = '\u0041'; // Also 'A'

// Overflow wraps silently!
int max = Integer.MAX_VALUE; // 2,147,483,647
int overflow = max + 1; // -2,147,483,648 (no exception!)

Autoboxing and Unboxing#

// Autoboxing: primitive → wrapper (automatic)
Integer boxed = 42; // int → Integer
List<Integer> list = new ArrayList<>();
list.add(5); // int → Integer (autoboxed)

// Unboxing: wrapper → primitive (automatic)
int unboxed = boxed; // Integer → int
int sum = boxed + 10; // Unbox, add, result is int

// DANGER: NullPointerException on unboxing null
Integer nullable = null;
int crash = nullable; // NullPointerException!

// Integer cache: -128 to 127 are cached
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true (same cached object)

Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false (different objects!)
System.out.println(c.equals(d)); // true (value comparison)

Strings#

// Strings are immutable objects
String s = "Hello";
s.toUpperCase(); // Returns NEW string; s is unchanged
String upper = s.toUpperCase(); // "HELLO"

// String pool (interning)
String a = "hello"; // Goes to string pool
String b = "hello"; // Same reference from pool
String c = new String("hello"); // New object on heap (avoid this)
a == b; // true (same reference)
a == c; // false (different objects)
a.equals(c); // true (same content) — ALWAYS use .equals() for strings

// StringBuilder for concatenation in loops
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
 sb.append("item ").append(i).append("\n");
}
String result = sb.toString();

// Text blocks (Java 13+)
String json = """
 {
 "name": "Alice",
 "age": 30
 }
 """;

// Useful methods
"Hello World".substring(0, 5); // "Hello"
"Hello World".split(" "); // ["Hello", "World"]
" spaces ".strip(); // "spaces" (Java 11+)
"Hello".contains("ell"); // true
"Hello".startsWith("He"); // true
String.format("Name: %s, Age: %d", name, age);
"Hello %s".formatted("World"); // Java 15+

Type Inference (var)#

// Local variable type inference (Java 10+)
var list = new ArrayList<String>(); // Inferred as ArrayList<String>
var map = Map.of("key", "value"); // Inferred as Map<String, String>
var stream = list.stream(); // Inferred as Stream<String>

// Where var CANNOT be used:
// - Method parameters
// - Return types
// - Fields (instance/class variables)
// - When initializer is null

// Good uses
var connection = DriverManager.getConnection(url); // Type is obvious
var entries = map.entrySet(); // Avoids verbose Set<Map.Entry<K,V>>

// Bad uses (reduces readability)
var result = process(data); // What type is result?
var x = 42; // Just use int

Arrays#

// Declaration and initialization
int[] numbers = new int[5]; // [0, 0, 0, 0, 0]
int[] primes = {2, 3, 5, 7, 11}; // Literal initialization
String[] names = new String[3]; // [null, null, null]

// Multi-dimensional
int[][] matrix = new int[3][4]; // 3 rows, 4 columns
int[][] jagged = { // Rows can have different lengths
 {1, 2, 3},
 {4, 5},
 {6, 7, 8, 9}
};

// Arrays are objects with fixed size
numbers.length; // 5 (field, not method)
// numbers[5]; // ArrayIndexOutOfBoundsException

// Utility methods
import java.util.Arrays;
Arrays.sort(numbers);
Arrays.fill(numbers, 0);
int[] copy = Arrays.copyOf(numbers, 10); // Extends with zeros
Arrays.equals(a, b); // Content comparison
Arrays.toString(numbers); // "[0, 0, 0, 0, 0]"

Control Flow#

// Enhanced switch (Java 14+) — expression form
String dayType = switch (day) {
 case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
 case SATURDAY, SUNDAY -> "Weekend";
};

// Switch with blocks
int numLetters = switch (day) {
 case MONDAY, FRIDAY, SUNDAY -> 6;
 case TUESDAY -> 7;
 case THURSDAY, SATURDAY -> 8;
 case WEDNESDAY -> 9;
 default -> throw new IllegalArgumentException("Invalid day: " + day);
};

// Pattern matching for instanceof (Java 16+)
if (obj instanceof String s) {
 // s is already cast to String — no explicit cast needed
 System.out.println(s.length());
}

// Pattern matching in switch (Java 21+)
String describe(Object obj) {
 return switch (obj) {
 case Integer i when i > 0 -> "Positive integer: " + i;
 case Integer i -> "Non-positive integer: " + i;
 case String s -> "String of length " + s.length();
 case null -> "null";
 default -> "Unknown: " + obj.getClass().getName();
 };
}

// For-each
for (String name : names) {
 System.out.println(name);
}

// Labeled break (for nested loops)
outer:
for (int i = 0; i < rows; i++) {
 for (int j = 0; j < cols; j++) {
 if (matrix[i][j] == target) {
 found = true;
 break outer; // Breaks out of BOTH loops
 }
 }
}

Records (Java 16+)#

// Records: immutable data carriers with auto-generated methods
public record Point(double x, double y) {
 // Auto-generated: constructor, getters (x(), y()), equals(), hashCode(), toString()
 
 // Compact constructor for validation
 public Point {
 if (Double.isNaN(x) || Double.isNaN(y)) {
 throw new IllegalArgumentException("Coordinates cannot be NaN");
 }
 }
 
 // Additional methods
 public double distanceTo(Point other) {
 return Math.sqrt(Math.pow(x - other.x, 2) + Math.pow(y - other.y, 2));
 }
}

// Usage
var p1 = new Point(3, 4);
var p2 = new Point(0, 0);
p1.x(); // 3.0 (accessor, not getX())
p1.distanceTo(p2); // 5.0
p1.toString(); // "Point[x=3.0, y=4.0]"

// Records in pattern matching
record Range(int min, int max) {}

static String classify(Range r) {
 return switch (r) {
 case Range(int min, int max) when min == max -> "Single value: " + min;
 case Range(int min, int max) when max - min < 10 -> "Narrow range";
 case Range(int min, int max) -> "Wide range: " + min + " to " + max;
 };
}

Sealed Classes (Java 17+)#

// Sealed: restricts which classes can extend/implement
public sealed interface Shape permits Circle, Rectangle, Triangle {
 double area();
}

public record Circle(double radius) implements Shape {
 public double area() { return Math.PI * radius * radius; }
}

public record Rectangle(double width, double height) implements Shape {
 public double area() { return width * height; }
}

public record Triangle(double base, double height) implements Shape {
 public double area() { return 0.5 * base * height; }
}

// Exhaustive pattern matching — compiler knows all subtypes
String describe(Shape shape) {
 return switch (shape) {
 case Circle c -> "Circle with radius " + c.radius();
 case Rectangle r -> "Rectangle " + r.width() + "x" + r.height();
 case Triangle t -> "Triangle with base " + t.base();
 // No default needed — sealed type is exhaustive
 };
}

Hypothetical Use Case: Type-Safe Configuration#

public sealed interface ConfigValue permits StringValue, IntValue, BoolValue, ListValue {
 String key();
}

public record StringValue(String key, String value) implements ConfigValue {}
public record IntValue(String key, int value) implements ConfigValue {}
public record BoolValue(String key, boolean value) implements ConfigValue {}
public record ListValue(String key, List<String> values) implements ConfigValue {}

public class Config {
 private final Map<String, ConfigValue> entries = new HashMap<>();
 
 public void set(ConfigValue value) {
 entries.put(value.key(), value);
 }
 
 public String getString(String key) {
 return switch (entries.get(key)) {
 case StringValue sv -> sv.value();
 case IntValue iv -> String.valueOf(iv.value());
 case BoolValue bv -> String.valueOf(bv.value());
 case ListValue lv -> String.join(",", lv.values());
 case null -> throw new NoSuchElementException("Key not found: " + key);
 };
 }
}

Key Takeaways#

Primitives live on the stack — wrappers are objects on the heap (autoboxing has cost)
Always use .equals() for object comparison — == compares references
Strings are immutable — use StringBuilder for repeated concatenation
var is for local variables only — use when the type is obvious from context
Records replace boilerplate data classes — immutable, with auto-generated methods
Sealed types + pattern matching enable exhaustive, type-safe branching
Integer cache (-128 to 127) means == works for small boxed integers but fails for larger ones

Java: Object-Oriented Programming

Mon, 01 Jan 0001 00:00:00 +0000

Classes and Objects#

Anatomy of a Java Class#

public class Employee {
 // Fields (instance variables)
 private final String id;
 private String name;
 private double salary;
 private Department department;
 
 // Static field (class-level)
 private static int totalEmployees = 0;
 
 // Constructor
 public Employee(String id, String name, double salary) {
 this.id = id;
 this.name = name;
 this.salary = salary;
 totalEmployees++;
 }
 
 // Overloaded constructor (constructor chaining)
 public Employee(String id, String name) {
 this(id, name, 50000.0); // Delegates to main constructor
 }
 
 // Getters and setters (encapsulation)
 public String getName() { return name; }
 
 public void setSalary(double salary) {
 if (salary < 0) throw new IllegalArgumentException("Salary cannot be negative");
 this.salary = salary;
 }
 
 // Business method
 public double annualBonus() {
 return salary * 0.10;
 }
 
 // Static method
 public static int getTotalEmployees() {
 return totalEmployees;
 }
 
 // Object methods override
 @Override
 public String toString() {
 return "Employee{id='%s', name='%s', salary=%.2f}".formatted(id, name, salary);
 }
 
 @Override
 public boolean equals(Object o) {
 if (this == o) return true;
 if (!(o instanceof Employee other)) return false;
 return id.equals(other.id);
 }
 
 @Override
 public int hashCode() {
 return id.hashCode();
 }
}

Inheritance#

public abstract class Shape {
 private final String color;
 
 protected Shape(String color) {
 this.color = color;
 }
 
 // Abstract method — subclasses MUST implement
 public abstract double area();
 public abstract double perimeter();
 
 // Concrete method — inherited as-is
 public String describe() {
 return "%s %s (area=%.2f)".formatted(color, getClass().getSimpleName(), area());
 }
 
 // Final method — CANNOT be overridden
 public final String getColor() {
 return color;
 }
}

public class Circle extends Shape {
 private final double radius;
 
 public Circle(String color, double radius) {
 super(color); // Must call parent constructor
 this.radius = radius;
 }
 
 @Override
 public double area() {
 return Math.PI * radius * radius;
 }
 
 @Override
 public double perimeter() {
 return 2 * Math.PI * radius;
 }
}

public class Rectangle extends Shape {
 private final double width, height;
 
 public Rectangle(String color, double width, double height) {
 super(color);
 this.width = width;
 this.height = height;
 }
 
 @Override
 public double area() { return width * height; }
 
 @Override
 public double perimeter() { return 2 * (width + height); }
}

Interfaces#

// Interfaces define contracts (what, not how)
public interface Sortable<T> {
 int compareTo(T other);
 
 // Default method (Java 8+) — provides implementation
 default boolean isGreaterThan(T other) {
 return compareTo(other) > 0;
 }
 
 // Static method
 static <T extends Sortable<T>> T max(T a, T b) {
 return a.compareTo(b) >= 0 ? a : b;
 }
}

public interface Serializable {
 byte[] serialize();
 
 // Private method (Java 9+) — helper for default methods
 private String formatHeader() {
 return "v1:" + getClass().getName();
 }
 
 default byte[] serializeWithHeader() {
 return (formatHeader() + ":" + new String(serialize())).getBytes();
 }
}

// A class can implement multiple interfaces
public class Product implements Sortable<Product>, Serializable {
 private final String name;
 private final double price;
 
 @Override
 public int compareTo(Product other) {
 return Double.compare(this.price, other.price);
 }
 
 @Override
 public byte[] serialize() {
 return (name + ":" + price).getBytes();
 }
}

Interface vs Abstract Class#

Feature	Interface	Abstract Class
Multiple inheritance	Yes (implements many)	No (extends one)
Fields	Constants only (`static final`)	Any fields
Constructors	No	Yes
Access modifiers	`public` (default methods)	Any
Use when	Defining a capability/contract	Sharing code among related classes

Polymorphism#

// Runtime polymorphism — method dispatch based on actual type
List<Shape> shapes = List.of(
 new Circle("red", 5),
 new Rectangle("blue", 3, 4),
 new Circle("green", 2)
);

for (Shape shape : shapes) {
 // Calls the correct area() based on actual runtime type
 System.out.println(shape.describe());
}

// Covariant return types
class Animal {
 public Animal create() { return new Animal(); }
}

class Dog extends Animal {
 @Override
 public Dog create() { return new Dog(); } // More specific return type OK
}

Composition and Delegation#

// Prefer composition over inheritance
public class OrderService {
 private final OrderRepository repository;
 private final PaymentGateway paymentGateway;
 private final NotificationService notifications;
 
 // Dependencies injected via constructor
 public OrderService(
 OrderRepository repository,
 PaymentGateway paymentGateway,
 NotificationService notifications) {
 this.repository = repository;
 this.paymentGateway = paymentGateway;
 this.notifications = notifications;
 }
 
 public Order placeOrder(OrderRequest request) {
 Order order = Order.from(request);
 
 PaymentResult payment = paymentGateway.charge(
 request.paymentMethod(), order.total()
 );
 
 if (!payment.isSuccessful()) {
 throw new PaymentFailedException(payment.errorMessage());
 }
 
 order = order.withStatus(OrderStatus.CONFIRMED);
 repository.save(order);
 notifications.sendOrderConfirmation(order);
 
 return order;
 }
}

Enums — Type-Safe Constants#

public enum HttpStatus {
 OK(200, "OK"),
 CREATED(201, "Created"),
 BAD_REQUEST(400, "Bad Request"),
 UNAUTHORIZED(401, "Unauthorized"),
 NOT_FOUND(404, "Not Found"),
 INTERNAL_ERROR(500, "Internal Server Error");
 
 private final int code;
 private final String message;
 
 HttpStatus(int code, String message) {
 this.code = code;
 this.message = message;
 }
 
 public int code() { return code; }
 public String message() { return message; }
 
 public boolean isSuccess() { return code >= 200 && code < 300; }
 public boolean isClientError() { return code >= 400 && code < 500; }
 public boolean isServerError() { return code >= 500; }
 
 // Lookup by code
 public static HttpStatus fromCode(int code) {
 for (HttpStatus status : values()) {
 if (status.code == code) return status;
 }
 throw new IllegalArgumentException("Unknown HTTP status: " + code);
 }
}

// Enum with abstract method (strategy pattern)
public enum Operation {
 ADD {
 @Override public double apply(double a, double b) { return a + b; }
 },
 SUBTRACT {
 @Override public double apply(double a, double b) { return a - b; }
 },
 MULTIPLY {
 @Override public double apply(double a, double b) { return a * b; }
 };
 
 public abstract double apply(double a, double b);
}

double result = Operation.ADD.apply(3, 4); // 7.0

SOLID Principles in Java#

Single Responsibility#

// BAD: UserService does too much
class UserService {
 void createUser(User u) { /* ... */ }
 void sendEmail(User u, String msg) { /* ... */ }
 String generateReport(List<User> users) { /* ... */ }
}

// GOOD: Each class has one reason to change
class UserService { void createUser(User u) { /* ... */ } }
class EmailService { void send(String to, String msg) { /* ... */ } }
class UserReportGenerator { String generate(List<User> users) { /* ... */ } }

Open/Closed (via interfaces)#

// Open for extension, closed for modification
interface DiscountStrategy {
 double apply(double price);
}

class PercentageDiscount implements DiscountStrategy {
 private final double percent;
 PercentageDiscount(double percent) { this.percent = percent; }
 public double apply(double price) { return price * (1 - percent / 100); }
}

class FixedDiscount implements DiscountStrategy {
 private final double amount;
 FixedDiscount(double amount) { this.amount = amount; }
 public double apply(double price) { return Math.max(0, price - amount); }
}

// Adding new discount types doesn't modify existing code
class BuyOneGetOneFree implements DiscountStrategy {
 public double apply(double price) { return price / 2; }
}

Dependency Inversion#

// HIGH-level modules should not depend on LOW-level modules.
// Both should depend on abstractions.

// BAD: OrderService depends on concrete MySQLRepository
class OrderService {
 private MySQLOrderRepository repo = new MySQLOrderRepository();
}

// GOOD: Depend on abstraction
class OrderService {
 private final OrderRepository repo; // Interface
 
 OrderService(OrderRepository repo) { // Injected
 this.repo = repo;
 }
}
// Now works with MySQL, Postgres, InMemory, Mock...

Hypothetical Use Case: Event-Driven Domain Model#

public sealed interface DomainEvent permits OrderCreated, OrderShipped, OrderCancelled {
 String orderId();
 Instant occurredAt();
}

public record OrderCreated(String orderId, String customerId, Instant occurredAt) 
 implements DomainEvent {}

public record OrderShipped(String orderId, String trackingNumber, Instant occurredAt) 
 implements DomainEvent {}

public record OrderCancelled(String orderId, String reason, Instant occurredAt) 
 implements DomainEvent {}

public class Order {
 private final String id;
 private OrderStatus status;
 private final List<DomainEvent> events = new ArrayList<>();
 
 public void ship(String trackingNumber) {
 if (status != OrderStatus.CONFIRMED) {
 throw new IllegalStateException("Cannot ship " + status + " order");
 }
 status = OrderStatus.SHIPPED;
 events.add(new OrderShipped(id, trackingNumber, Instant.now()));
 }
 
 public List<DomainEvent> drainEvents() {
 var drained = List.copyOf(events);
 events.clear();
 return drained;
 }
}

Key Takeaways#

Encapsulation — fields private, access via methods (getters/setters or business methods)
Favor composition over inheritance — inject dependencies, delegate behavior
Interfaces define contracts — use them for polymorphism and testability
Enums are powerful — they can have fields, methods, and implement interfaces
Records (Java 16+) eliminate data class boilerplate
Sealed types (Java 17+) enable exhaustive pattern matching
SOLID principles guide class design — especially Dependency Inversion for testability

Java: Generics and Type Erasure

Mon, 01 Jan 0001 00:00:00 +0000

Why Generics#

// Without generics — no type safety, requires casting
List rawList = new ArrayList();
rawList.add("hello");
rawList.add(42); // No compile error!
String s = (String) rawList.get(1); // ClassCastException at RUNTIME

// With generics — compile-time type safety
List<String> typedList = new ArrayList<>();
typedList.add("hello");
// typedList.add(42); // Compile error!
String s = typedList.get(0); // No cast needed

Generic Classes#

public class Pair<A, B> {
 private final A first;
 private final B second;
 
 public Pair(A first, B second) {
 this.first = first;
 this.second = second;
 }
 
 public A first() { return first; }
 public B second() { return second; }
 
 public <C> Pair<C, B> mapFirst(Function<A, C> mapper) {
 return new Pair<>(mapper.apply(first), second);
 }
 
 @Override
 public String toString() {
 return "(%s, %s)".formatted(first, second);
 }
}

// Usage
Pair<String, Integer> nameAge = new Pair<>("Alice", 30);
Pair<Integer, Integer> coordinates = new Pair<>(10, 20);

Generic Interface with Multiple Implementations#

public interface Repository<T, ID> {
 Optional<T> findById(ID id);
 List<T> findAll();
 T save(T entity);
 void deleteById(ID id);
 boolean existsById(ID id);
}

public class InMemoryUserRepository implements Repository<User, String> {
 private final Map<String, User> store = new ConcurrentHashMap<>();
 
 @Override
 public Optional<User> findById(String id) {
 return Optional.ofNullable(store.get(id));
 }
 
 @Override
 public List<User> findAll() {
 return List.copyOf(store.values());
 }
 
 @Override
 public User save(User user) {
 store.put(user.id(), user);
 return user;
 }
 
 @Override
 public void deleteById(String id) {
 store.remove(id);
 }
 
 @Override
 public boolean existsById(String id) {
 return store.containsKey(id);
 }
}

Bounded Type Parameters#

// Upper bound: T must be Comparable
public static <T extends Comparable<T>> T max(T a, T b) {
 return a.compareTo(b) >= 0 ? a : b;
}

max(3, 7); // 7
max("apple", "banana"); // "banana"

// Multiple bounds: T must implement BOTH interfaces
public static <T extends Comparable<T> & Serializable> void process(T item) {
 // Can use both Comparable and Serializable methods
}

// Bounded in class definition
public class SortedList<T extends Comparable<T>> {
 private final List<T> items = new ArrayList<>();
 
 public void add(T item) {
 int index = Collections.binarySearch(items, item);
 if (index < 0) index = -(index + 1);
 items.add(index, item);
 }
 
 public List<T> asList() {
 return Collections.unmodifiableList(items);
 }
}

Wildcards#

graph TD
 A["Object"] --> B["Number"]
 B --> C["Integer"]
 B --> D["Double"]
 B --> E["Long"]
 
 style A fill:#e1f5fe
 style B fill:#fff3e0
 style C fill:#c8e6c9
 style D fill:#c8e6c9
 style E fill:#c8e6c9

// Unbounded wildcard: ? — read-only, any type
void printAll(List<?> list) {
 for (Object item : list) {
 System.out.println(item);
 }
 // list.add(???); // Can't add — don't know the type!
}

// Upper bounded: ? extends Number — "producer" (read from)
double sum(List<? extends Number> numbers) {
 double total = 0;
 for (Number n : numbers) {
 total += n.doubleValue(); // Can read as Number
 }
 // numbers.add(42); // Can't add — might be List<Double>!
 return total;
}

sum(List.of(1, 2, 3)); // Works with List<Integer>
sum(List.of(1.5, 2.5)); // Works with List<Double>

// Lower bounded: ? super Integer — "consumer" (write to)
void addNumbers(List<? super Integer> list) {
 list.add(1); // Can add Integer (or subtype)
 list.add(2);
 // Integer x = list.get(0); // Can't read as Integer — might be List<Object>!
 Object x = list.get(0); // Can only read as Object
}

addNumbers(new ArrayList<Integer>()); // OK
addNumbers(new ArrayList<Number>()); // OK
addNumbers(new ArrayList<Object>()); // OK

PECS: Producer Extends, Consumer Super#

// Copy from source (producer) to destination (consumer)
public static <T> void copy(List<? extends T> source, List<? super T> dest) {
 for (T item : source) {
 dest.add(item);
 }
}

List<Integer> ints = List.of(1, 2, 3);
List<Number> nums = new ArrayList<>();
copy(ints, nums); // Integer extends Number, Number super Integer

Type Erasure#

What Happens at Runtime#

// What you write:
List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();

// What the JVM sees (after erasure):
List strings = new ArrayList(); // Generic type info is GONE
List integers = new ArrayList();

// Consequence:
strings.getClass() == integers.getClass(); // true! Both are ArrayList

// You CANNOT do:
// if (obj instanceof List<String>) {} // Compile error
// new T() // Compile error
// new T[] // Compile error
// T.class // Compile error

Working Around Erasure#

// Problem: can't create generic arrays
// T[] array = new T[10]; // Won't compile

// Solution 1: pass Class<T> token
public class TypeSafeContainer<T> {
 private final Class<T> type;
 private final Object[] storage;
 private int size = 0;
 
 public TypeSafeContainer(Class<T> type, int capacity) {
 this.type = type;
 this.storage = new Object[capacity];
 }
 
 public void add(T item) {
 storage[size++] = item;
 }
 
 public T get(int index) {
 return type.cast(storage[index]); // Safe cast using Class token
 }
}

// Solution 2: use @SuppressWarnings with documented reason
@SuppressWarnings("unchecked") // Safe: array never exposed outside class
T[] createArray(int size) {
 return (T[]) new Object[size];
}

Erasure and Overloading#

// This WON'T compile — both erase to process(List)
// void process(List<String> strings) { }
// void process(List<Integer> integers) { }

// Fix: use different method names or a single generic method
<T> void process(List<T> items, Class<T> type) { }

Generic Methods#

public class Collections {
 
 // Generic method — type parameter declared before return type
 public static <T> List<T> singletonList(T item) {
 return List.of(item);
 }
 
 // Multiple type parameters
 public static <K, V> Map<K, V> mapOf(K key, V value) {
 return Map.of(key, value);
 }
 
 // Bounded generic method
 public static <T extends Comparable<T>> Optional<T> min(Collection<T> items) {
 return items.stream().min(Comparable::compareTo);
 }
 
 // Recursive type bound (self-referential)
 public static <T extends Comparable<T>> void sort(List<T> list) {
 list.sort(Comparable::compareTo);
 }
}

// Type inference — compiler figures out T
List<String> list = Collections.singletonList("hello"); // T = String
Optional<Integer> min = Collections.min(List.of(3, 1, 4)); // T = Integer

Hypothetical Use Case: Type-Safe Builder#

public class QueryBuilder<T> {
 private final Class<T> entityType;
 private final List<String> conditions = new ArrayList<>();
 private String orderBy;
 private int limit = -1;
 
 private QueryBuilder(Class<T> entityType) {
 this.entityType = entityType;
 }
 
 public static <T> QueryBuilder<T> from(Class<T> entityType) {
 return new QueryBuilder<>(entityType);
 }
 
 public QueryBuilder<T> where(String condition) {
 conditions.add(condition);
 return this;
 }
 
 public QueryBuilder<T> orderBy(String field) {
 this.orderBy = field;
 return this;
 }
 
 public QueryBuilder<T> limit(int limit) {
 this.limit = limit;
 return this;
 }
 
 public Query<T> build() {
 return new Query<>(entityType, conditions, orderBy, limit);
 }
}

// Usage — fully type-safe
Query<User> query = QueryBuilder.from(User.class)
 .where("age > 18")
 .where("active = true")
 .orderBy("name")
 .limit(50)
 .build();

List<User> users = database.execute(query); // Returns List<User>, not List<Object>

Key Takeaways#

Generics provide compile-time type safety — catch errors before runtime
Type erasure means generic info is gone at runtime — can’t do instanceof List<String>
PECS — Producer Extends, Consumer Super (read from extends, write to super)
Bounded types (<T extends X>) restrict what types can be used
Wildcards (?) are for flexibility in method parameters
Pass Class<T> when you need type info at runtime (erasure workaround)
Prefer generic methods over raw types — never use raw List, always List<T>

Java: Collections Framework

Mon, 01 Jan 0001 00:00:00 +0000

The Collections Hierarchy#

graph TD
 I["Iterable"] --> C["Collection"]
 C --> L["List"]
 C --> S["Set"]
 C --> Q["Queue"]
 
 L --> AL["ArrayList"]
 L --> LL["LinkedList"]
 L --> CL["CopyOnWriteArrayList"]
 
 S --> HS["HashSet"]
 S --> TS["TreeSet"]
 S --> LHS["LinkedHashSet"]
 
 Q --> PQ["PriorityQueue"]
 Q --> D["Deque"]
 D --> AD["ArrayDeque"]
 
 M["Map"] --> HM["HashMap"]
 M --> TM["TreeMap"]
 M --> LHM["LinkedHashMap"]
 M --> CHM["ConcurrentHashMap"]

List Implementations#

ArrayList — Dynamic Array#

// O(1) random access, O(1) amortized append, O(n) insert/remove at index
List<String> names = new ArrayList<>();
names.add("Alice"); // O(1) amortized
names.add(0, "Bob"); // O(n) — shifts elements
names.get(0); // O(1) — direct index access
names.remove(0); // O(n) — shifts elements
names.contains("Alice"); // O(n) — linear scan

// Pre-size when you know the capacity
List<Integer> large = new ArrayList<>(10_000);

// Immutable list (Java 9+)
List<String> immutable = List.of("a", "b", "c");
// immutable.add("d"); // UnsupportedOperationException

LinkedList — Doubly-Linked List#

// O(1) add/remove at head/tail, O(n) random access
LinkedList<String> queue = new LinkedList<>();
queue.addFirst("first"); // O(1)
queue.addLast("last"); // O(1)
queue.removeFirst(); // O(1)
queue.get(5); // O(n) — must traverse

// Use as Deque (double-ended queue)
Deque<String> deque = new LinkedList<>();
deque.offerFirst("front");
deque.offerLast("back");
deque.pollFirst(); // Remove from front
deque.pollLast(); // Remove from back

When to Use Which#

Operation	ArrayList	LinkedList
Random access (`get(i)`)	O(1) ✓	O(n) ✗
Append (`add(e)`)	O(1) amortized ✓	O(1) ✓
Insert at index	O(n)	O(1) if at iterator position
Memory overhead	Low (contiguous)	High (node objects + pointers)
Default choice	Yes	Rarely needed

Set Implementations#

// HashSet — O(1) add/remove/contains, unordered
Set<String> tags = new HashSet<>();
tags.add("java");
tags.add("java"); // Duplicate ignored
tags.contains("java"); // O(1)

// TreeSet — O(log n) operations, sorted order
Set<Integer> sorted = new TreeSet<>();
sorted.addAll(List.of(5, 2, 8, 1, 9));
// Iteration order: 1, 2, 5, 8, 9

NavigableSet<Integer> nav = new TreeSet<>(sorted);
nav.headSet(5); // {1, 2} — elements < 5
nav.tailSet(5); // {5, 8, 9} — elements >= 5
nav.subSet(2, 8); // {2, 5} — elements in [2, 8)

// LinkedHashSet — O(1) operations, insertion order preserved
Set<String> ordered = new LinkedHashSet<>();
ordered.add("first");
ordered.add("second");
ordered.add("third");
// Iteration order: first, second, third (insertion order)

// Set operations
Set<Integer> a = Set.of(1, 2, 3, 4);
Set<Integer> b = Set.of(3, 4, 5, 6);

// Union
Set<Integer> union = new HashSet<>(a);
union.addAll(b); // {1, 2, 3, 4, 5, 6}

// Intersection
Set<Integer> intersection = new HashSet<>(a);
intersection.retainAll(b); // {3, 4}

// Difference
Set<Integer> difference = new HashSet<>(a);
difference.removeAll(b); // {1, 2}

Map Implementations#

// HashMap — O(1) average, unordered
Map<String, Integer> wordCount = new HashMap<>();
wordCount.put("hello", 1);
wordCount.get("hello"); // 1
wordCount.getOrDefault("world", 0); // 0

// Compute patterns (Java 8+)
wordCount.merge("hello", 1, Integer::sum); // Increment or set to 1
wordCount.computeIfAbsent("key", k -> expensiveComputation(k));
wordCount.computeIfPresent("hello", (k, v) -> v + 1);

// TreeMap — O(log n), sorted by key
Map<String, Integer> sorted = new TreeMap<>(wordCount);
// Keys in alphabetical order

NavigableMap<LocalDate, Event> timeline = new TreeMap<>();
timeline.floorEntry(today); // Latest entry <= today
timeline.ceilingEntry(today); // Earliest entry >= today
timeline.subMap(startDate, endDate); // Range query

// LinkedHashMap — insertion order OR access order
// Access-order mode: LRU cache
Map<String, String> lruCache = new LinkedHashMap<>(16, 0.75f, true) {
 @Override
 protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
 return size() > 100; // Evict when cache exceeds 100 entries
 }
};

// Map.of (immutable, Java 9+)
Map<String, Integer> config = Map.of(
 "timeout", 30,
 "retries", 3,
 "port", 8080
);

Queue and Deque#

// PriorityQueue — min-heap by default
Queue<Integer> minHeap = new PriorityQueue<>();
minHeap.offer(5);
minHeap.offer(1);
minHeap.offer(3);
minHeap.poll(); // 1 (smallest)
minHeap.poll(); // 3
minHeap.poll(); // 5

// Max-heap
Queue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());

// Custom priority
record Task(String name, int priority) {}
Queue<Task> taskQueue = new PriorityQueue<>(
 Comparator.comparingInt(Task::priority).reversed()
);

// ArrayDeque — faster than LinkedList for stack/queue use
Deque<String> stack = new ArrayDeque<>();
stack.push("first"); // addFirst
stack.push("second");
stack.pop(); // "second" (LIFO)

Deque<String> queue = new ArrayDeque<>();
queue.offer("first"); // addLast
queue.offer("second");
queue.poll(); // "first" (FIFO)

Collections Utility Class#

import java.util.Collections;

// Sorting
List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));
Collections.sort(names); // Natural order
names.sort(Comparator.reverseOrder()); // Reverse
names.sort(Comparator.comparingInt(String::length)); // By length

// Multi-key sorting
List<Employee> employees = getEmployees();
employees.sort(
 Comparator.comparing(Employee::department)
 .thenComparing(Employee::salary, Comparator.reverseOrder())
 .thenComparing(Employee::name)
);

// Unmodifiable wrappers
List<String> readOnly = Collections.unmodifiableList(names);
// readOnly.add("x"); // UnsupportedOperationException

// Thread-safe wrappers (prefer ConcurrentHashMap for maps)
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// Searching (list must be sorted)
int index = Collections.binarySearch(sortedList, "target");

// Frequency and disjoint
int count = Collections.frequency(list, "hello");
boolean noCommon = Collections.disjoint(set1, set2);

Concurrent Collections#

import java.util.concurrent.*;

// ConcurrentHashMap — thread-safe, high-performance map
ConcurrentMap<String, AtomicLong> counters = new ConcurrentHashMap<>();

// Atomic compute operations (no external synchronization needed)
counters.computeIfAbsent("requests", k -> new AtomicLong()).incrementAndGet();

// CopyOnWriteArrayList — thread-safe list for read-heavy workloads
List<EventListener> listeners = new CopyOnWriteArrayList<>();
// Writes copy the entire array (expensive)
// Reads never block (fast, no locking)

// BlockingQueue — producer-consumer pattern
BlockingQueue<Task> workQueue = new LinkedBlockingQueue<>(1000);

// Producer
workQueue.put(new Task("process")); // Blocks if full

// Consumer
Task task = workQueue.take(); // Blocks if empty

// ConcurrentSkipListMap — sorted, concurrent map
ConcurrentNavigableMap<String, Integer> sortedConcurrent = new ConcurrentSkipListMap<>();

Hypothetical Use Case: In-Memory Index#

public class InvertedIndex {
 // word → set of document IDs containing that word
 private final Map<String, Set<String>> index = new HashMap<>();
 
 public void indexDocument(String docId, String content) {
 String[] words = content.toLowerCase().split("\\W+");
 for (String word : words) {
 index.computeIfAbsent(word, k -> new HashSet<>()).add(docId);
 }
 }
 
 public Set<String> search(String query) {
 String[] terms = query.toLowerCase().split("\\W+");
 
 // AND search: documents must contain ALL terms
 return Arrays.stream(terms)
 .map(term -> index.getOrDefault(term, Set.of()))
 .reduce((a, b) -> {
 Set<String> intersection = new HashSet<>(a);
 intersection.retainAll(b);
 return intersection;
 })
 .orElse(Set.of());
 }
 
 public List<Map.Entry<String, Integer>> topTerms(int n) {
 return index.entrySet().stream()
 .map(e -> Map.entry(e.getKey(), e.getValue().size()))
 .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
 .limit(n)
 .toList();
 }
}

Key Takeaways#

ArrayList is the default List — use LinkedList only for frequent head/tail operations
HashSet/HashMap for O(1) lookups — TreeSet/TreeMap when you need sorted order
Use Map.computeIfAbsent instead of check-then-put patterns
ArrayDeque > LinkedList for stack and queue use cases
Immutable collections (List.of, Map.of) for constants and return values
ConcurrentHashMap for thread-safe maps — never Collections.synchronizedMap
Choose the right collection based on access patterns, not familiarity

Java: Exception Handling

Mon, 01 Jan 0001 00:00:00 +0000

Exception Hierarchy#

graph TD
 T["Throwable"] --> E["Exception"]
 T --> Er["Error"]
 
 E --> RE["RuntimeException<br>(unchecked)"]
 E --> CE["Checked Exceptions"]
 
 RE --> NPE["NullPointerException"]
 RE --> IAE["IllegalArgumentException"]
 RE --> ISE["IllegalStateException"]
 RE --> IOOBE["IndexOutOfBoundsException"]
 RE --> CCE["ClassCastException"]
 RE --> UOE["UnsupportedOperationException"]
 
 CE --> IOE["IOException"]
 CE --> SQLE["SQLException"]
 CE --> FNFE["FileNotFoundException"]
 
 Er --> OOM["OutOfMemoryError"]
 Er --> SOE["StackOverflowError"]
 
 style RE fill:#fff3e0
 style CE fill:#e1f5fe
 style Er fill:#ffcdd2

Checked vs Unchecked#

	Checked	Unchecked (Runtime)	Error
Must handle?	Yes (catch or declare)	No	No
Represents	Recoverable conditions	Programming bugs	JVM failures
Examples	IOException, SQLException	NullPointerException, IllegalArgumentException	OutOfMemoryError
Declare with	`throws` in signature	Nothing	Nothing

Try-With-Resources#

// Automatic resource management (Java 7+)
// Resources implementing AutoCloseable are closed automatically
public String readFile(Path path) throws IOException {
 try (var reader = Files.newBufferedReader(path);
 var lines = reader.lines()) {
 return lines.collect(Collectors.joining("\n"));
 }
 // reader.close() called automatically, even on exception
}

// Multiple resources — closed in reverse order
public void copyFile(Path source, Path dest) throws IOException {
 try (var in = new BufferedInputStream(Files.newInputStream(source));
 var out = new BufferedOutputStream(Files.newOutputStream(dest))) {
 in.transferTo(out);
 }
}

// Custom AutoCloseable
public class DatabaseConnection implements AutoCloseable {
 private final Connection conn;
 
 public DatabaseConnection(String url) throws SQLException {
 this.conn = DriverManager.getConnection(url);
 }
 
 @Override
 public void close() throws SQLException {
 if (conn != null && !conn.isClosed()) {
 conn.close();
 }
 }
}

// Usage
try (var db = new DatabaseConnection("jdbc:postgresql://localhost/mydb")) {
 db.query("SELECT * FROM users");
} // Automatically closed

Custom Exception Design#

// Base application exception
public class AppException extends RuntimeException {
 private final String errorCode;
 private final Map<String, Object> context;
 
 public AppException(String message, String errorCode) {
 this(message, errorCode, null, Map.of());
 }
 
 public AppException(String message, String errorCode, Throwable cause, Map<String, Object> context) {
 super(message, cause);
 this.errorCode = errorCode;
 this.context = Map.copyOf(context);
 }
 
 public String errorCode() { return errorCode; }
 public Map<String, Object> context() { return context; }
}

// Specific exceptions
public class EntityNotFoundException extends AppException {
 public EntityNotFoundException(String entityType, Object id) {
 super(
 "%s with id '%s' not found".formatted(entityType, id),
 "NOT_FOUND",
 null,
 Map.of("entityType", entityType, "id", id.toString())
 );
 }
}

public class ValidationException extends AppException {
 private final List<FieldError> fieldErrors;
 
 public ValidationException(List<FieldError> errors) {
 super("Validation failed: " + errors.size() + " error(s)", "VALIDATION_ERROR");
 this.fieldErrors = List.copyOf(errors);
 }
 
 public List<FieldError> fieldErrors() { return fieldErrors; }
 
 public record FieldError(String field, String message, Object rejectedValue) {}
}

public class ConflictException extends AppException {
 public ConflictException(String resource, String conflictReason) {
 super(
 "Conflict on %s: %s".formatted(resource, conflictReason),
 "CONFLICT",
 null,
 Map.of("resource", resource, "reason", conflictReason)
 );
 }
}

Exception Handling Patterns#

Translate Low-Level to Domain Exceptions#

public class UserRepository {
 public User findById(String id) {
 try {
 return jdbcTemplate.queryForObject(
 "SELECT * FROM users WHERE id = ?",
 userRowMapper, id
 );
 } catch (EmptyResultDataAccessException e) {
 throw new EntityNotFoundException("User", id);
 } catch (DataAccessException e) {
 throw new AppException(
 "Database error while fetching user",
 "DB_ERROR", e, Map.of("userId", id)
 );
 }
 }
}

Multi-Catch and Rethrow#

public void processFile(Path path) {
 try {
 var content = Files.readString(path);
 var data = parseJson(content);
 validate(data);
 save(data);
 } catch (IOException | JsonParseException e) {
 // Multi-catch: handle multiple exception types the same way
 throw new ProcessingException("Failed to process " + path, e);
 } catch (ValidationException e) {
 // Handle differently
 log.warn("Validation failed for {}: {}", path, e.fieldErrors());
 throw e; // Rethrow as-is
 }
}

Finally vs Try-With-Resources#

// OLD way (pre-Java 7) — error-prone
Connection conn = null;
try {
 conn = getConnection();
 // use connection
} finally {
 if (conn != null) {
 try {
 conn.close(); // close() can also throw!
 } catch (SQLException e) {
 log.error("Failed to close connection", e);
 }
 }
}

// MODERN way — clean and correct
try (var conn = getConnection()) {
 // use connection
}
// Suppressed exceptions from close() are attached to the primary exception

Optional — Avoiding NullPointerException#

import java.util.Optional;

// Creating Optionals
Optional<String> present = Optional.of("hello"); // Must be non-null
Optional<String> empty = Optional.empty();
Optional<String> nullable = Optional.ofNullable(null); // May be null

// Using Optionals (NEVER call .get() without checking)
public Optional<User> findUser(String id) {
 User user = database.query(id);
 return Optional.ofNullable(user);
}

// Consuming
findUser("123")
 .map(User::email)
 .filter(email -> email.contains("@"))
 .ifPresentOrElse(
 email -> sendNotification(email),
 () -> log.warn("User not found or invalid email")
 );

// Chaining
String displayName = findUser("123")
 .map(User::displayName)
 .orElse("Anonymous");

// orElseThrow (preferred over .get())
User user = findUser("123")
 .orElseThrow(() -> new EntityNotFoundException("User", "123"));

// Flattening nested Optionals
Optional<String> city = findUser("123")
 .flatMap(User::address) // address() returns Optional<Address>
 .map(Address::city);

// Stream integration (Java 9+)
List<String> emails = userIds.stream()
 .map(this::findUser)
 .flatMap(Optional::stream) // Filters out empty Optionals
 .map(User::email)
 .toList();

Optional Anti-Patterns#

// BAD: Optional as method parameter
void process(Optional<String> name) { } // Don't do this

// GOOD: Use overloading or nullable parameter
void process(String name) { }
void process() { process(null); }

// BAD: Optional for fields
class User {
 Optional<String> middleName; // Don't do this
}

// GOOD: Nullable field, Optional return
class User {
 private String middleName; // May be null
 public Optional<String> middleName() { return Optional.ofNullable(middleName); }
}

// BAD: isPresent() + get()
if (optional.isPresent()) {
 doSomething(optional.get());
}

// GOOD: ifPresent or map
optional.ifPresent(this::doSomething);
optional.map(this::transform).orElse(defaultValue);

Hypothetical Use Case: Resilient Service Layer#

public class OrderService {
 private final OrderRepository orderRepo;
 private final PaymentClient paymentClient;
 private final InventoryClient inventoryClient;
 
 public Order placeOrder(OrderRequest request) {
 // Validate
 var errors = validate(request);
 if (!errors.isEmpty()) {
 throw new ValidationException(errors);
 }
 
 // Check inventory
 try {
 inventoryClient.reserve(request.items());
 } catch (InsufficientStockException e) {
 throw new ConflictException("inventory", 
 "Items out of stock: " + e.unavailableItems());
 }
 
 // Process payment
 PaymentResult payment;
 try {
 payment = paymentClient.charge(request.paymentMethod(), request.total());
 } catch (PaymentDeclinedException e) {
 inventoryClient.release(request.items()); // Compensate
 throw new AppException("Payment declined", "PAYMENT_DECLINED", e,
 Map.of("reason", e.declineReason()));
 } catch (Exception e) {
 inventoryClient.release(request.items()); // Compensate
 throw new AppException("Payment processing failed", "PAYMENT_ERROR", e, Map.of());
 }
 
 // Create order
 var order = Order.create(request, payment.transactionId());
 return orderRepo.save(order);
 }
}

Key Takeaways#

Use unchecked exceptions for programming errors (IllegalArgumentException, IllegalStateException)
Use checked exceptions only when the caller can meaningfully recover
Try-with-resources for ALL closeable resources — never manual finally blocks
Translate exceptions at layer boundaries (SQL → domain exception)
Optional for return types that may be absent — never for fields or parameters
Never catch Exception or Throwable broadly — catch specific types
Include context in exceptions — what operation failed, with what inputs
Suppressed exceptions from try-with-resources are accessible via getSuppressed()

Java: Concurrency

Mon, 01 Jan 0001 00:00:00 +0000

Thread Fundamentals#

// Creating threads
// Option 1: Runnable (preferred — separates task from execution)
Runnable task = () -> System.out.println("Running in " + Thread.currentThread().getName());
Thread thread = new Thread(task, "worker-1");
thread.start(); // Starts new thread
thread.join(); // Wait for completion

// Option 2: Callable (returns a value, can throw checked exceptions)
Callable<Integer> computation = () -> {
 Thread.sleep(1000);
 return 42;
};

Thread States#

stateDiagram-v2
 [*] --> NEW: Thread created
 NEW --> RUNNABLE: start()
 RUNNABLE --> BLOCKED: waiting for lock
 RUNNABLE --> WAITING: wait()/join()
 RUNNABLE --> TIMED_WAITING: sleep()/wait(timeout)
 BLOCKED --> RUNNABLE: lock acquired
 WAITING --> RUNNABLE: notify()/join completes
 TIMED_WAITING --> RUNNABLE: timeout/notify
 RUNNABLE --> TERMINATED: run() completes
 TERMINATED --> [*]

ExecutorService — Thread Pool Management#

import java.util.concurrent.*;

// Fixed thread pool — bounded, reuses threads
ExecutorService fixedPool = Executors.newFixedThreadPool(4);

// Cached pool — unbounded, creates threads as needed
ExecutorService cachedPool = Executors.newCachedThreadPool();

// Single thread — sequential execution, guaranteed ordering
ExecutorService singleThread = Executors.newSingleThreadExecutor();

// Virtual threads (Java 21+) — lightweight, millions possible
ExecutorService virtualPool = Executors.newVirtualThreadPerTaskExecutor();

// Custom pool with full control
ThreadPoolExecutor custom = new ThreadPoolExecutor(
 4, // core pool size
 16, // max pool size
 60, TimeUnit.SECONDS, // idle thread timeout
 new LinkedBlockingQueue<>(1000), // work queue (bounded!)
 new ThreadPoolExecutor.CallerRunsPolicy() // rejection policy
);

Submitting Tasks#

ExecutorService executor = Executors.newFixedThreadPool(4);

// Submit Runnable (no return value)
executor.submit(() -> processItem(item));

// Submit Callable (returns Future)
Future<String> future = executor.submit(() -> fetchData(url));

// Get result (blocks until complete)
try {
 String result = future.get(30, TimeUnit.SECONDS);
} catch (TimeoutException e) {
 future.cancel(true); // Interrupt the task
} catch (ExecutionException e) {
 Throwable cause = e.getCause(); // Original exception
}

// Submit multiple tasks
List<Callable<String>> tasks = urls.stream()
 .map(url -> (Callable<String>) () -> fetchData(url))
 .toList();

List<Future<String>> futures = executor.invokeAll(tasks); // Wait for all
String fastest = executor.invokeAny(tasks); // Return first to complete

// Shutdown
executor.shutdown(); // No new tasks, finish existing
executor.awaitTermination(60, TimeUnit.SECONDS);

CompletableFuture — Async Composition#

import java.util.concurrent.CompletableFuture;

// Async computation
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 return fetchUserData(userId);
});

// Chaining transformations
CompletableFuture<OrderSummary> pipeline = CompletableFuture
 .supplyAsync(() -> fetchUser(userId))
 .thenApply(user -> fetchOrders(user.id())) // Transform result
 .thenApply(orders -> summarize(orders)) // Transform again
 .exceptionally(ex -> { // Handle errors
 log.error("Pipeline failed", ex);
 return OrderSummary.empty();
 });

// Combining multiple futures
CompletableFuture<String> userFuture = CompletableFuture.supplyAsync(() -> fetchUser(id));
CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> fetchOrders(id));
CompletableFuture<Double> balanceFuture = CompletableFuture.supplyAsync(() -> fetchBalance(id));

// Wait for all
CompletableFuture<Void> allDone = CompletableFuture.allOf(userFuture, ordersFuture, balanceFuture);
allDone.thenRun(() -> {
 String user = userFuture.join();
 List<Order> orders = ordersFuture.join();
 Double balance = balanceFuture.join();
 buildDashboard(user, orders, balance);
});

// Combine two futures
CompletableFuture<String> combined = userFuture.thenCombine(
 ordersFuture,
 (user, orders) -> "%s has %d orders".formatted(user, orders.size())
);

// Timeout (Java 9+)
CompletableFuture<String> withTimeout = future
 .orTimeout(5, TimeUnit.SECONDS)
 .exceptionally(ex -> "Timed out");

Synchronization#

synchronized and Locks#

// synchronized — intrinsic lock
public class Counter {
 private int count = 0;
 
 public synchronized void increment() { // Lock on 'this'
 count++;
 }
 
 public synchronized int get() {
 return count;
 }
}

// ReentrantLock — more flexible
public class BoundedBuffer<T> {
 private final Queue<T> queue = new LinkedList<>();
 private final int capacity;
 private final ReentrantLock lock = new ReentrantLock();
 private final Condition notFull = lock.newCondition();
 private final Condition notEmpty = lock.newCondition();
 
 public BoundedBuffer(int capacity) {
 this.capacity = capacity;
 }
 
 public void put(T item) throws InterruptedException {
 lock.lock();
 try {
 while (queue.size() == capacity) {
 notFull.await(); // Wait until space available
 }
 queue.add(item);
 notEmpty.signal(); // Wake up consumers
 } finally {
 lock.unlock();
 }
 }
 
 public T take() throws InterruptedException {
 lock.lock();
 try {
 while (queue.isEmpty()) {
 notEmpty.await(); // Wait until item available
 }
 T item = queue.remove();
 notFull.signal(); // Wake up producers
 return item;
 } finally {
 lock.unlock();
 }
 }
}

Atomic Variables — Lock-Free#

import java.util.concurrent.atomic.*;

// AtomicInteger — thread-safe without locks
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet(); // Atomic increment
counter.compareAndSet(5, 10); // CAS: set to 10 only if currently 5

// AtomicReference — for object references
AtomicReference<Config> configRef = new AtomicReference<>(loadConfig());
configRef.updateAndGet(current -> current.withTimeout(30));

// LongAdder — better than AtomicLong for high-contention counters
LongAdder requestCount = new LongAdder();
requestCount.increment(); // Distributed across cells
requestCount.sum(); // Aggregate when needed

Virtual Threads (Java 21+)#

// Virtual threads: lightweight, managed by JVM, not OS
// Can create millions without exhausting memory

// Simple creation
Thread.startVirtualThread(() -> {
 var result = blockingHttpCall(url);
 process(result);
});

// With executor
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
 List<Future<String>> futures = urls.stream()
 .map(url -> executor.submit(() -> fetch(url)))
 .toList();
 
 List<String> results = futures.stream()
 .map(f -> {
 try { return f.get(); }
 catch (Exception e) { return "error"; }
 })
 .toList();
}

// Structured Concurrency (Preview, Java 21+)
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
 Subtask<String> user = scope.fork(() -> fetchUser(id));
 Subtask<List<Order>> orders = scope.fork(() -> fetchOrders(id));
 
 scope.join(); // Wait for all
 scope.throwIfFailed(); // Propagate first failure
 
 return new Dashboard(user.get(), orders.get());
}

When to Use Virtual vs Platform Threads#

Use Virtual Threads	Use Platform Threads
I/O-bound tasks (HTTP, DB, file)	CPU-bound computation
High concurrency (thousands of tasks)	Low concurrency with shared mutable state
Simple blocking code style	Need thread-local storage
Replacing reactive/async frameworks	Pinning concerns (synchronized blocks)

Common Concurrency Patterns#

Producer-Consumer#

BlockingQueue<Task> queue = new LinkedBlockingQueue<>(100);

// Producers
for (int i = 0; i < 3; i++) {
 executor.submit(() -> {
 while (!Thread.interrupted()) {
 Task task = generateTask();
 queue.put(task); // Blocks if queue is full
 }
 });
}

// Consumers
for (int i = 0; i < 5; i++) {
 executor.submit(() -> {
 while (!Thread.interrupted()) {
 Task task = queue.take(); // Blocks if queue is empty
 process(task);
 }
 });
}

Read-Write Lock#

public class CachedData<T> {
 private T data;
 private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
 
 public T read() {
 rwLock.readLock().lock(); // Multiple readers allowed
 try {
 return data;
 } finally {
 rwLock.readLock().unlock();
 }
 }
 
 public void write(T newData) {
 rwLock.writeLock().lock(); // Exclusive access
 try {
 this.data = newData;
 } finally {
 rwLock.writeLock().unlock();
 }
 }
}

Hypothetical Use Case: Parallel API Aggregator#

public class DashboardService {
 private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
 
 public Dashboard buildDashboard(String userId) {
 var userFuture = CompletableFuture.supplyAsync(() -> userService.getUser(userId), executor);
 var ordersFuture = CompletableFuture.supplyAsync(() -> orderService.getRecent(userId), executor);
 var metricsFuture = CompletableFuture.supplyAsync(() -> metricsService.getSummary(userId), executor);
 var notifFuture = CompletableFuture.supplyAsync(() -> notificationService.getUnread(userId), executor);
 
 CompletableFuture.allOf(userFuture, ordersFuture, metricsFuture, notifFuture)
 .orTimeout(5, TimeUnit.SECONDS)
 .join();
 
 return new Dashboard(
 userFuture.join(),
 ordersFuture.join(),
 metricsFuture.resultNow(),
 notifFuture.resultNow()
 );
 }
}

Key Takeaways#

Never use raw Thread — use ExecutorService for thread management
CompletableFuture for async composition — chain, combine, handle errors
Virtual threads (Java 21+) replace reactive frameworks for I/O-bound work
Prefer AtomicInteger/LongAdder over synchronized for simple counters
Bounded queues prevent memory exhaustion in producer-consumer patterns
Always shut down executors — use try-with-resources (Java 19+) or shutdown/awaitTermination
Avoid synchronized on public methods — use private lock objects
Structured concurrency (preview) makes concurrent code as readable as sequential

Java: Streams and Functional Programming

Mon, 01 Jan 0001 00:00:00 +0000

Functional Interfaces#

// A functional interface has exactly ONE abstract method
@FunctionalInterface
interface Transformer<T, R> {
 R transform(T input);
}

// Built-in functional interfaces (java.util.function)
Function<String, Integer> // T → R
Predicate<String> // T → boolean
Consumer<String> // T → void
Supplier<String> // () → T
UnaryOperator<String> // T → T (same type)
BinaryOperator<Integer> // (T, T) → T
BiFunction<String, Integer, Boolean> // (T, U) → R

Lambda Expressions#

// Lambda syntax
Comparator<String> byLength = (a, b) -> Integer.compare(a.length(), b.length());
Predicate<Integer> isPositive = n -> n > 0;
Consumer<String> printer = System.out::println; // Method reference

// Method references (4 types)
Function<String, Integer> parse = Integer::parseInt; // Static method
Function<String, String> upper = String::toUpperCase; // Instance method (unbound)
Supplier<List<String>> factory = ArrayList::new; // Constructor
Consumer<String> print = System.out::println; // Instance method (bound)

// Effectively final — lambdas capture variables that don't change
String prefix = "Hello"; // Effectively final
Function<String, String> greeter = name -> prefix + " " + name;
// prefix = "Hi"; // Would make it non-effectively-final → compile error

Stream API#

Stream Pipeline#

flowchart LR
 S["Source<br>(Collection, array, generator)"] --> I1["filter()"]
 I1 --> I2["map()"]
 I2 --> I3["sorted()"]
 I3 --> T["Terminal<br>(collect, forEach, reduce)"]
 
 style S fill:#e1f5fe
 style I1 fill:#fff3e0
 style I2 fill:#fff3e0
 style I3 fill:#fff3e0
 style T fill:#c8e6c9

List<String> names = List.of("Alice", "Bob", "Charlie", "Diana", "Eve");

// Basic pipeline
List<String> result = names.stream()
 .filter(name -> name.length() > 3) // Intermediate: filter
 .map(String::toUpperCase) // Intermediate: transform
 .sorted() // Intermediate: sort
 .toList(); // Terminal: collect
// ["ALICE", "CHARLIE", "DIANA"]

// Streams are LAZY — nothing happens until terminal operation
Stream<String> lazy = names.stream()
 .filter(name -> {
 System.out.println("Filtering: " + name); // Not printed yet!
 return name.length() > 3;
 });
// No output until: lazy.toList() or lazy.forEach(...)

Common Operations#

List<Order> orders = getOrders();

// filter — keep elements matching predicate
List<Order> expensive = orders.stream()
 .filter(o -> o.total() > 100)
 .toList();

// map — transform each element
List<String> emails = orders.stream()
 .map(Order::customerEmail)
 .toList();

// flatMap — one-to-many transformation (flatten nested collections)
List<OrderItem> allItems = orders.stream()
 .flatMap(order -> order.items().stream())
 .toList();

// distinct, sorted, limit, skip
List<String> uniqueSorted = names.stream()
 .distinct()
 .sorted()
 .limit(5)
 .toList();

// peek — debug (don't use for side effects in production)
orders.stream()
 .peek(o -> log.debug("Processing order: {}", o.id()))
 .filter(Order::isPending)
 .forEach(this::processOrder);

// anyMatch, allMatch, noneMatch
boolean hasExpensive = orders.stream().anyMatch(o -> o.total() > 1000);
boolean allShipped = orders.stream().allMatch(o -> o.status() == SHIPPED);

// findFirst, findAny
Optional<Order> first = orders.stream()
 .filter(o -> o.customer().equals("Alice"))
 .findFirst();

// count
long pendingCount = orders.stream()
 .filter(Order::isPending)
 .count();

Collectors#

import java.util.stream.Collectors;

// toList, toSet, toMap
Map<String, Order> orderById = orders.stream()
 .collect(Collectors.toMap(Order::id, Function.identity()));

// groupingBy
Map<OrderStatus, List<Order>> byStatus = orders.stream()
 .collect(Collectors.groupingBy(Order::status));

// groupingBy with downstream collector
Map<String, Double> totalByCustomer = orders.stream()
 .collect(Collectors.groupingBy(
 Order::customerId,
 Collectors.summingDouble(Order::total)
 ));

Map<OrderStatus, Long> countByStatus = orders.stream()
 .collect(Collectors.groupingBy(
 Order::status,
 Collectors.counting()
 ));

// partitioningBy (split into true/false groups)
Map<Boolean, List<Order>> partitioned = orders.stream()
 .collect(Collectors.partitioningBy(o -> o.total() > 100));
List<Order> expensive = partitioned.get(true);
List<Order> cheap = partitioned.get(false);

// joining
String csv = names.stream()
 .collect(Collectors.joining(", ", "[", "]"));
// "[Alice, Bob, Charlie]"

// statistics
DoubleSummaryStatistics stats = orders.stream()
 .collect(Collectors.summarizingDouble(Order::total));
stats.getAverage(); // mean
stats.getMax(); // maximum
stats.getCount(); // count

Reduce#

// reduce — fold elements into a single value
int sum = List.of(1, 2, 3, 4, 5).stream()
 .reduce(0, Integer::sum); // 15

Optional<Integer> max = numbers.stream()
 .reduce(Integer::max);

// Complex reduce
String concatenated = words.stream()
 .reduce("", (a, b) -> a.isEmpty() ? b : a + ", " + b);

// Parallel-safe reduce with combiner
int parallelSum = numbers.parallelStream()
 .reduce(0, Integer::sum, Integer::sum);
// identity accumulator combiner

Primitive Streams#

// Avoid boxing overhead for numeric operations
IntStream.range(0, 100) // 0 to 99
 .filter(n -> n % 2 == 0)
 .sum(); // 2450

IntStream.rangeClosed(1, 10) // 1 to 10
 .average() // OptionalDouble
 .orElse(0.0);

// Convert between object and primitive streams
List<String> words = List.of("hello", "world", "java");
IntStream lengths = words.stream().mapToInt(String::length);
Stream<Integer> boxed = IntStream.range(0, 10).boxed();

// Generate streams
DoubleStream.generate(Math::random).limit(10);
IntStream.iterate(1, n -> n * 2).limit(10); // 1, 2, 4, 8, 16...

Parallel Streams#

// Parallel processing — uses ForkJoinPool
long count = hugeList.parallelStream()
 .filter(item -> expensiveCheck(item))
 .count();

// When to use parallel streams:
// ✓ Large datasets (>10,000 elements)
// ✓ CPU-bound operations (no I/O)
// ✓ Stateless, independent operations
// ✓ Source supports efficient splitting (ArrayList, arrays)

// When NOT to use:
// ✗ Small datasets (overhead > benefit)
// ✗ I/O-bound operations (use async instead)
// ✗ Order-dependent operations
// ✗ LinkedList (poor splitting)
// ✗ Shared mutable state

// Custom thread pool for parallel streams
ForkJoinPool customPool = new ForkJoinPool(8);
List<Result> results = customPool.submit(() ->
 items.parallelStream()
 .map(this::heavyComputation)
 .toList()
).get();

Practical Patterns#

Data Transformation Pipeline#

public record SalesReport(
 String region,
 double totalRevenue,
 long orderCount,
 double averageOrderValue
) {}

public List<SalesReport> generateReport(List<Order> orders) {
 return orders.stream()
 .filter(o -> o.status() == OrderStatus.COMPLETED)
 .collect(Collectors.groupingBy(Order::region))
 .entrySet().stream()
 .map(entry -> {
 String region = entry.getKey();
 List<Order> regionOrders = entry.getValue();
 double total = regionOrders.stream().mapToDouble(Order::total).sum();
 long count = regionOrders.size();
 return new SalesReport(region, total, count, total / count);
 })
 .sorted(Comparator.comparingDouble(SalesReport::totalRevenue).reversed())
 .toList();
}

Optional + Stream Composition#

public Optional<String> findBestOffer(String customerId) {
 return findCustomer(customerId)
 .map(Customer::loyaltyTier)
 .flatMap(tier -> getOffers(tier).stream()
 .filter(Offer::isActive)
 .max(Comparator.comparingDouble(Offer::discount))
 .map(Offer::code));
}

Key Takeaways#

Streams are lazy — intermediate operations do nothing until a terminal operation triggers execution
Streams are single-use — cannot be reused after a terminal operation
Prefer method references (String::toUpperCase) over lambdas when possible
flatMap for one-to-many transformations (nested collections, Optional chains)
Use primitive streams (IntStream, DoubleStream) to avoid boxing overhead
Parallel streams only for CPU-bound work on large datasets with good splittability
Collectors.groupingBy with downstream collectors replaces complex loops
Never mutate external state from within a stream — streams assume stateless operations

Java: Memory Management and Garbage Collection

Mon, 01 Jan 0001 00:00:00 +0000

Object Lifecycle#

stateDiagram-v2
 [*] --> Allocated: new Object()
 Allocated --> Reachable: referenced
 Reachable --> Unreachable: no more references
 Unreachable --> Finalized: GC marks for collection
 Finalized --> Deallocated: memory reclaimed
 Deallocated --> [*]

What Makes an Object Eligible for GC?#

public void example() {
 // Object created — reachable via 'user' reference
 User user = new User("Alice");
 
 // Still reachable
 processUser(user);
 
 // Reference reassigned — original User object is now unreachable
 user = new User("Bob");
 // "Alice" User is eligible for GC (no references point to it)
 
 // Explicit null (rarely needed — scope exit does the same)
 user = null;
 // "Bob" User is now eligible for GC
}
// Both objects eligible for GC when method returns (stack frame popped)

Reference Types#

import java.lang.ref.*;

// Strong reference (default) — object NEVER collected while referenced
Object strong = new Object();

// Weak reference — collected at next GC if no strong refs exist
WeakReference<Object> weak = new WeakReference<>(new Object());
weak.get(); // May return null if collected

// Soft reference — collected only when memory is low (good for caches)
SoftReference<byte[]> cache = new SoftReference<>(loadLargeData());
byte[] data = cache.get(); // null if memory pressure caused collection

// Phantom reference — for cleanup actions (replaces finalize())
PhantomReference<Object> phantom = new PhantomReference<>(obj, referenceQueue);

// WeakHashMap — entries removed when keys are no longer strongly referenced
Map<Key, Value> cache = new WeakHashMap<>();

Heap Generations#

flowchart LR
 subgraph Young["Young Generation"]
 E["Eden"]
 S0["Survivor 0"]
 S1["Survivor 1"]
 end
 
 subgraph Old["Old Generation (Tenured)"]
 OG["Long-lived objects"]
 end
 
 E -->|"Minor GC<br>survivors"| S0
 S0 -->|"Next Minor GC"| S1
 S1 -->|"Age threshold<br>reached"| OG

How Generational GC Works#

New objects allocated in Eden
Minor GC — when Eden fills up:
- Live objects copied to Survivor space
- Eden cleared (very fast — most objects are dead)
Objects survive multiple Minor GCs → promoted to Old Generation
Major GC (Full GC) — when Old Gen fills up:
- Scans entire heap (expensive, causes pauses)

Why Generational?#

Weak Generational Hypothesis: Most objects die young.

Java: Build Tools

Mon, 01 Jan 0001 00:00:00 +0000

Maven vs Gradle#

Feature	Maven	Gradle
Config format	XML (`pom.xml`)	Groovy/Kotlin DSL (`build.gradle.kts`)
Build model	Declarative, convention-based	Declarative + imperative
Performance	Slower (no incremental builds)	Faster (incremental, build cache, daemon)
Dependency resolution	Nearest-wins	Latest-wins (configurable)
Learning curve	Lower (rigid conventions)	Higher (flexible, more concepts)
Ecosystem	Largest plugin ecosystem	Growing, Kotlin-first
Best for	Enterprise, Spring Boot, libraries	Android, multi-module, custom builds

Maven#

Project Structure (Convention over Configuration)#

my-project/
├── pom.xml
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/example/myapp/
│ │ │ └── Application.java
│ │ └── resources/
│ │ └── application.yml
│ └── test/
│ ├── java/
│ │ └── com/example/myapp/
│ │ └── ApplicationTest.java
│ └── resources/
│ └── test-config.yml
└── target/ # Build output (generated)

pom.xml Anatomy#

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 
 <!-- Project coordinates (GAV) -->
 <groupId>com.example</groupId>
 <artifactId>my-service</artifactId>
 <version>1.2.0</version>
 <packaging>jar</packaging>
 
 <!-- Parent POM (inherit config) -->
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>3.3.0</version>
 </parent>
 
 <!-- Properties (version management) -->
 <properties>
 <java.version>21</java.version>
 <mapstruct.version>1.5.5.Final</mapstruct.version>
 </properties>
 
 <!-- Dependencies -->
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 
 <dependency>
 <groupId>org.postgresql</groupId>
 <artifactId>postgresql</artifactId>
 <scope>runtime</scope>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 </dependencies>
 
 <!-- Build plugins -->
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>
</project>

Maven Lifecycle#

flowchart LR
 V["validate"] --> C["compile"]
 C --> T["test"]
 T --> P["package"]
 P --> VE["verify"]
 VE --> I["install"]
 I --> D["deploy"]

# Common commands
mvn clean # Delete target/
mvn compile # Compile main sources
mvn test # Run unit tests
mvn package # Create JAR/WAR
mvn install # Install to local repo (~/.m2)
mvn deploy # Upload to remote repo

# Skip tests
mvn package -DskipTests # Skip test execution
mvn package -Dmaven.test.skip=true # Skip compilation AND execution

# Run Spring Boot
mvn spring-boot:run

# Dependency tree (debug conflicts)
mvn dependency:tree
mvn dependency:tree -Dincludes=com.fasterxml.jackson

Dependency Scopes#

Scope	Compile	Test	Runtime	Packaged
`compile` (default)	✓	✓	✓	✓
`provided`	✓	✓	✗	✗
`runtime`	✗	✓	✓	✓
`test`	✗	✓	✗	✗

Gradle (Kotlin DSL)#

build.gradle.kts#

plugins {
 java
 id("org.springframework.boot") version "3.3.0"
 id("io.spring.dependency-management") version "1.1.5"
}

group = "com.example"
version = "1.2.0"

java {
 toolchain {
 languageVersion = JavaLanguageVersion.of(21)
 }
}

repositories {
 mavenCentral()
}

dependencies {
 implementation("org.springframework.boot:spring-boot-starter-web")
 implementation("org.postgresql:postgresql")
 
 testImplementation("org.springframework.boot:spring-boot-starter-test")
 testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.test {
 useJUnitPlatform()
}

# Common commands
./gradlew build # Full build
./gradlew test # Run tests
./gradlew bootRun # Run Spring Boot app
./gradlew dependencies # Dependency tree
./gradlew clean build -x test # Build without tests

Multi-Module Projects#

Maven Multi-Module#

<!-- parent/pom.xml -->
<project>
 <groupId>com.example</groupId>
 <artifactId>my-platform</artifactId>
 <version>1.0.0</version>
 <packaging>pom</packaging>
 
 <modules>
 <module>common</module>
 <module>api</module>
 <module>service</module>
 </modules>
 
 <dependencyManagement>
 <dependencies>
 <!-- Centralize versions here -->
 <dependency>
 <groupId>com.example</groupId>
 <artifactId>common</artifactId>
 <version>${project.version}</version>
 </dependency>
 </dependencies>
 </dependencyManagement>
</project>

my-platform/
├── pom.xml (parent)
├── common/
│ ├── pom.xml
│ └── src/
├── api/
│ ├── pom.xml
│ └── src/
└── service/
 ├── pom.xml
 └── src/

Dependency Management Best Practices#

<!-- BOM (Bill of Materials) — centralize versions -->
<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2023.0.1</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
</dependencyManagement>

<!-- Now use without specifying version -->
<dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
 <!-- Version managed by BOM -->
 </dependency>
</dependencies>

Resolving Conflicts#

# Find conflicting versions
mvn dependency:tree -Dverbose -Dincludes=com.fasterxml.jackson

# Exclude transitive dependency

<dependency>
 <groupId>com.example</groupId>
 <artifactId>library-a</artifactId>
 <exclusions>
 <exclusion>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-databind</artifactId>
 </exclusion>
 </exclusions>
</dependency>

Key Takeaways#

Maven for convention — rigid structure, less configuration, huge ecosystem
Gradle for flexibility — faster builds, better for multi-module and custom workflows
Always use dependency management (BOM or <dependencyManagement>) to centralize versions
mvn dependency:tree is your best friend for debugging classpath issues
Use proper scopes — test for test libs, runtime for JDBC drivers, provided for servlet API
Multi-module for shared code — parent POM manages versions, children inherit
Never commit build output (target/, build/) — only source and config

Java: Testing

Mon, 01 Jan 0001 00:00:00 +0000

JUnit 5 Architecture#

graph TD
 JP["JUnit Platform<br>(launcher, engine API)"] --> JJ["JUnit Jupiter<br>(JUnit 5 tests)"]
 JP --> JV["JUnit Vintage<br>(JUnit 3/4 compat)"]
 JP --> TE["Third-party engines<br>(TestNG, etc.)"]

Writing Tests#

Basic Test Structure#

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {
 
 private Calculator calculator;
 
 @BeforeEach
 void setUp() {
 calculator = new Calculator();
 }
 
 @Test
 @DisplayName("Addition of two positive numbers")
 void addPositiveNumbers() {
 assertEquals(5, calculator.add(2, 3));
 }
 
 @Test
 void divideByZeroThrowsException() {
 ArithmeticException ex = assertThrows(
 ArithmeticException.class,
 () -> calculator.divide(10, 0)
 );
 assertEquals("/ by zero", ex.getMessage());
 }
 
 @Test
 void multipleAssertionsGrouped() {
 var result = calculator.compute(10, 5);
 
 assertAll("computation results",
 () -> assertEquals(15, result.sum()),
 () -> assertEquals(5, result.difference()),
 () -> assertEquals(50, result.product()),
 () -> assertEquals(2.0, result.quotient())
 );
 }
 
 @Test
 @Disabled("Bug #123 — fix pending")
 void knownBrokenTest() {
 // Skipped until bug is fixed
 }
}

Parameterized Tests#

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;

class ValidationTest {
 
 @ParameterizedTest
 @ValueSource(strings = {"alice@example.com", "bob@test.org", "user+tag@domain.co"})
 void validEmails(String email) {
 assertTrue(EmailValidator.isValid(email));
 }
 
 @ParameterizedTest
 @NullAndEmptySource
 @ValueSource(strings = {"not-an-email", "@missing.local", "spaces in@email.com"})
 void invalidEmails(String email) {
 assertFalse(EmailValidator.isValid(email));
 }
 
 @ParameterizedTest
 @CsvSource({
 "1, 1, 2",
 "0, 0, 0",
 "-1, 1, 0",
 "100, 200, 300"
 })
 void additionCases(int a, int b, int expected) {
 assertEquals(expected, calculator.add(a, b));
 }
 
 @ParameterizedTest
 @MethodSource("orderTestCases")
 void orderTotalCalculation(List<OrderItem> items, double expectedTotal) {
 Order order = new Order(items);
 assertEquals(expectedTotal, order.total(), 0.01);
 }
 
 static Stream<Arguments> orderTestCases() {
 return Stream.of(
 Arguments.of(List.of(new OrderItem("A", 10.0, 2)), 20.0),
 Arguments.of(List.of(new OrderItem("B", 5.0, 3)), 15.0),
 Arguments.of(List.of(), 0.0)
 );
 }
}

Nested Tests#

@DisplayName("Order")
class OrderTest {
 
 private Order order;
 
 @BeforeEach
 void setUp() {
 order = new Order("ORD-001", "customer-1");
 }
 
 @Nested
 @DisplayName("when new")
 class WhenNew {
 @Test
 void hasNoItems() {
 assertTrue(order.items().isEmpty());
 }
 
 @Test
 void hasPendingStatus() {
 assertEquals(OrderStatus.PENDING, order.status());
 }
 
 @Test
 void canAddItems() {
 order.addItem(new OrderItem("Widget", 9.99, 1));
 assertEquals(1, order.items().size());
 }
 }
 
 @Nested
 @DisplayName("when confirmed")
 class WhenConfirmed {
 @BeforeEach
 void confirm() {
 order.addItem(new OrderItem("Widget", 9.99, 1));
 order.confirm();
 }
 
 @Test
 void cannotAddMoreItems() {
 assertThrows(IllegalStateException.class,
 () -> order.addItem(new OrderItem("Gadget", 19.99, 1)));
 }
 
 @Test
 void canBeShipped() {
 assertDoesNotThrow(() -> order.ship("TRACK-123"));
 }
 }
}

Mockito#

import org.mockito.*;
import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
 
 @Mock
 private UserRepository userRepository;
 
 @Mock
 private EmailService emailService;
 
 @InjectMocks
 private UserService userService;
 
 @Test
 void createUser_savesAndSendsWelcomeEmail() {
 // Arrange
 var request = new CreateUserRequest("alice@example.com", "Alice");
 var savedUser = new User("u-123", "alice@example.com", "Alice");
 
 when(userRepository.save(any(User.class))).thenReturn(savedUser);
 
 // Act
 User result = userService.createUser(request);
 
 // Assert
 assertEquals("u-123", result.id());
 
 // Verify interactions
 verify(userRepository).save(argThat(user -> 
 user.email().equals("alice@example.com")
 ));
 verify(emailService).sendWelcome(eq("alice@example.com"), eq("Alice"));
 verifyNoMoreInteractions(emailService);
 }
 
 @Test
 void getUser_notFound_throwsException() {
 when(userRepository.findById("unknown")).thenReturn(Optional.empty());
 
 assertThrows(EntityNotFoundException.class,
 () -> userService.getUser("unknown"));
 }
 
 @Test
 void deleteUser_verifiesOrder() {
 var user = new User("u-1", "alice@example.com", "Alice");
 when(userRepository.findById("u-1")).thenReturn(Optional.of(user));
 
 userService.deleteUser("u-1");
 
 // Verify order of operations
 InOrder inOrder = inOrder(userRepository, emailService);
 inOrder.verify(userRepository).findById("u-1");
 inOrder.verify(emailService).sendAccountDeletion("alice@example.com");
 inOrder.verify(userRepository).delete("u-1");
 }
}

Argument Captors#

@Test
void auditLog_capturesCorrectDetails() {
 ArgumentCaptor<AuditEvent> captor = ArgumentCaptor.forClass(AuditEvent.class);
 
 userService.updateEmail("u-1", "new@example.com");
 
 verify(auditService).log(captor.capture());
 
 AuditEvent event = captor.getValue();
 assertEquals("EMAIL_CHANGED", event.action());
 assertEquals("u-1", event.userId());
 assertNotNull(event.timestamp());
}

Integration Testing with Spring Boot#

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
class OrderControllerIntegrationTest {
 
 @Container
 static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16")
 .withDatabaseName("testdb");
 
 @DynamicPropertySource
 static void configureProperties(DynamicPropertyRegistry registry) {
 registry.add("spring.datasource.url", postgres::getJdbcUrl);
 registry.add("spring.datasource.username", postgres::getUsername);
 registry.add("spring.datasource.password", postgres::getPassword);
 }
 
 @Autowired
 private TestRestTemplate restTemplate;
 
 @Autowired
 private OrderRepository orderRepository;
 
 @BeforeEach
 void setUp() {
 orderRepository.deleteAll();
 }
 
 @Test
 void createOrder_returnsCreatedStatus() {
 var request = new CreateOrderRequest("customer-1", List.of(
 new OrderItemRequest("Widget", 9.99, 2)
 ));
 
 ResponseEntity<Order> response = restTemplate.postForEntity(
 "/api/orders", request, Order.class
 );
 
 assertEquals(HttpStatus.CREATED, response.getStatusCode());
 assertNotNull(response.getBody().id());
 assertEquals(19.98, response.getBody().total(), 0.01);
 
 // Verify persisted
 assertTrue(orderRepository.findById(response.getBody().id()).isPresent());
 }
 
 @Test
 void getOrder_notFound_returns404() {
 ResponseEntity<String> response = restTemplate.getForEntity(
 "/api/orders/nonexistent", String.class
 );
 
 assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
 }
}

Test Patterns#

Builder Pattern for Test Data#

public class UserTestBuilder {
 private String id = "u-" + UUID.randomUUID().toString().substring(0, 8);
 private String email = "test@example.com";
 private String name = "Test User";
 private boolean active = true;
 
 public static UserTestBuilder aUser() {
 return new UserTestBuilder();
 }
 
 public UserTestBuilder withEmail(String email) {
 this.email = email;
 return this;
 }
 
 public UserTestBuilder inactive() {
 this.active = false;
 return this;
 }
 
 public User build() {
 return new User(id, email, name, active);
 }
}

// Usage in tests
var activeUser = UserTestBuilder.aUser().withEmail("alice@test.com").build();
var inactiveUser = UserTestBuilder.aUser().inactive().build();

Key Takeaways#

JUnit 5 — use @DisplayName for readable test names, @Nested for grouping
Parameterized tests eliminate duplicate test methods — one test, many inputs
Mockito for unit tests — mock dependencies, verify interactions
Testcontainers for integration tests — real databases in Docker
Test builders create readable test data without constructor noise
assertAll groups related assertions — all run even if one fails
Test behavior, not implementation — mock at boundaries, not internal methods
@SpringBootTest loads full context — use @WebMvcTest or @DataJpaTest for slices

Java: Enterprise Patterns — Spring Basics

Mon, 01 Jan 0001 00:00:00 +0000

Spring Framework Core Concepts#

flowchart TD
 subgraph Spring["Spring Framework"]
 IoC["IoC Container<br>(ApplicationContext)"]
 DI["Dependency Injection"]
 AOP["Aspect-Oriented Programming"]
 end
 
 subgraph Boot["Spring Boot"]
 AC["Auto-Configuration"]
 ST["Starters"]
 EM["Embedded Server"]
 ACT["Actuator"]
 end
 
 IoC --> DI
 Boot --> Spring

Inversion of Control (IoC)#

// WITHOUT IoC — class creates its own dependencies (tight coupling)
public class OrderService {
 private final OrderRepository repo = new JdbcOrderRepository(); // Hardcoded!
 private final EmailService email = new SmtpEmailService(); // Hardcoded!
}

// WITH IoC — Spring creates and injects dependencies
@Service
public class OrderService {
 private final OrderRepository repo; // Interface
 private final EmailService email; // Interface
 
 // Spring injects implementations at runtime
 public OrderService(OrderRepository repo, EmailService email) {
 this.repo = repo;
 this.email = email;
 }
}

Dependency Injection#

Component Scanning and Stereotypes#

@Component // Generic Spring-managed bean
@Service // Business logic layer
@Repository // Data access layer (adds exception translation)
@Controller // Web MVC controller
@RestController // @Controller + @ResponseBody
@Configuration // Declares @Bean methods

Injection Methods#

// 1. Constructor injection (PREFERRED — immutable, testable)
@Service
public class UserService {
 private final UserRepository userRepo;
 private final PasswordEncoder encoder;
 
 // @Autowired is optional on single constructor (Spring 4.3+)
 public UserService(UserRepository userRepo, PasswordEncoder encoder) {
 this.userRepo = userRepo;
 this.encoder = encoder;
 }
}

// 2. @Bean methods in @Configuration (for third-party classes)
@Configuration
public class AppConfig {
 
 @Bean
 public PasswordEncoder passwordEncoder() {
 return new BCryptPasswordEncoder(12);
 }
 
 @Bean
 @Profile("production")
 public DataSource productionDataSource() {
 var ds = new HikariDataSource();
 ds.setJdbcUrl("jdbc:postgresql://prod-db:5432/myapp");
 return ds;
 }
}

Profiles and Conditional Beans#

@Configuration
public class CacheConfig {
 
 @Bean
 @Profile("production")
 public CacheManager redisCacheManager(RedisConnectionFactory factory) {
 return RedisCacheManager.builder(factory).build();
 }
 
 @Bean
 @Profile("!production") // NOT production (test, dev)
 public CacheManager inMemoryCacheManager() {
 return new ConcurrentMapCacheManager("users", "orders");
 }
}

// application.yml
// spring.profiles.active: production

Spring Boot REST API#

Controller Layer#

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
 
 private final UserService userService;
 
 public UserController(UserService userService) {
 this.userService = userService;
 }
 
 @GetMapping
 public List<UserResponse> listUsers(
 @RequestParam(defaultValue = "0") int page,
 @RequestParam(defaultValue = "20") int size) {
 return userService.findAll(PageRequest.of(page, size))
 .map(UserResponse::from)
 .getContent();
 }
 
 @GetMapping("/{id}")
 public UserResponse getUser(@PathVariable String id) {
 return userService.findById(id)
 .map(UserResponse::from)
 .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
 }
 
 @PostMapping
 @ResponseStatus(HttpStatus.CREATED)
 public UserResponse createUser(@Valid @RequestBody CreateUserRequest request) {
 User user = userService.create(request);
 return UserResponse.from(user);
 }
 
 @PutMapping("/{id}")
 public UserResponse updateUser(@PathVariable String id, @Valid @RequestBody UpdateUserRequest request) {
 User user = userService.update(id, request);
 return UserResponse.from(user);
 }
 
 @DeleteMapping("/{id}")
 @ResponseStatus(HttpStatus.NO_CONTENT)
 public void deleteUser(@PathVariable String id) {
 userService.delete(id);
 }
}

Request/Response DTOs#

// Request validation with Jakarta Bean Validation
public record CreateUserRequest(
 @NotBlank(message = "Email is required")
 @Email(message = "Must be a valid email")
 String email,
 
 @NotBlank @Size(min = 2, max = 100)
 String name,
 
 @NotNull @Min(0) @Max(150)
 Integer age
) {}

// Response DTO (never expose entities directly)
public record UserResponse(
 String id,
 String email,
 String name,
 int age,
 Instant createdAt
) {
 public static UserResponse from(User user) {
 return new UserResponse(
 user.getId(), user.getEmail(), user.getName(),
 user.getAge(), user.getCreatedAt()
 );
 }
}

Global Exception Handling#

@RestControllerAdvice
public class GlobalExceptionHandler {
 
 @ExceptionHandler(EntityNotFoundException.class)
 @ResponseStatus(HttpStatus.NOT_FOUND)
 public ErrorResponse handleNotFound(EntityNotFoundException ex) {
 return new ErrorResponse("NOT_FOUND", ex.getMessage());
 }
 
 @ExceptionHandler(MethodArgumentNotValidException.class)
 @ResponseStatus(HttpStatus.BAD_REQUEST)
 public ErrorResponse handleValidation(MethodArgumentNotValidException ex) {
 List<FieldError> errors = ex.getBindingResult().getFieldErrors().stream()
 .map(fe -> new FieldError(fe.getField(), fe.getDefaultMessage()))
 .toList();
 return new ErrorResponse("VALIDATION_ERROR", "Validation failed", errors);
 }
 
 @ExceptionHandler(Exception.class)
 @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
 public ErrorResponse handleUnexpected(Exception ex) {
 log.error("Unexpected error", ex);
 return new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred");
 }
 
 public record ErrorResponse(String code, String message, List<FieldError> errors) {
 public ErrorResponse(String code, String message) {
 this(code, message, List.of());
 }
 }
 
 public record FieldError(String field, String message) {}
}

Spring Data JPA#

// Entity
@Entity
@Table(name = "users")
public class User {
 @Id
 @GeneratedValue(strategy = GenerationType.UUID)
 private String id;
 
 @Column(nullable = false, unique = true)
 private String email;
 
 @Column(nullable = false)
 private String name;
 
 @Enumerated(EnumType.STRING)
 private UserStatus status = UserStatus.ACTIVE;
 
 @CreatedDate
 private Instant createdAt;
 
 @LastModifiedDate
 private Instant updatedAt;
 
 // JPA requires no-arg constructor
 protected User() {}
 
 public User(String email, String name) {
 this.email = email;
 this.name = name;
 }
}

// Repository — Spring generates implementation automatically
public interface UserRepository extends JpaRepository<User, String> {
 
 Optional<User> findByEmail(String email);
 
 List<User> findByStatusAndCreatedAtAfter(UserStatus status, Instant after);
 
 @Query("SELECT u FROM User u WHERE u.name LIKE %:search% OR u.email LIKE %:search%")
 Page<User> search(@Param("search") String search, Pageable pageable);
 
 boolean existsByEmail(String email);
 
 @Modifying
 @Query("UPDATE User u SET u.status = :status WHERE u.id = :id")
 int updateStatus(@Param("id") String id, @Param("status") UserStatus status);
}

Application Configuration#

# application.yml
spring:
 application:
 name: my-service
 datasource:
 url: jdbc:postgresql://localhost:5432/mydb
 username: ${DB_USERNAME:postgres}
 password: ${DB_PASSWORD:secret}
 jpa:
 hibernate:
 ddl-auto: validate
 open-in-view: false
 
server:
 port: 8080

management:
 endpoints:
 web:
 exposure:
 include: health,info,metrics,prometheus
 endpoint:
 health:
 show-details: when-authorized

# Custom properties
app:
 feature-flags:
 new-checkout: true
 external-api:
 base-url: https://api.example.com
 timeout: 30s

// Type-safe configuration binding
@ConfigurationProperties(prefix = "app.external-api")
public record ExternalApiConfig(
 String baseUrl,
 Duration timeout
) {}

// Enable in main class
@SpringBootApplication
@EnableConfigurationProperties(ExternalApiConfig.class)
public class Application { }

Layered Architecture#

flowchart TD
 C["Controller<br>(@RestController)"] --> S["Service<br>(@Service)"]
 S --> R["Repository<br>(@Repository)"]
 R --> DB["Database"]
 
 C -.->|"DTO"| S
 S -.->|"Entity"| R
 
 style C fill:#e1f5fe
 style S fill:#fff3e0
 style R fill:#c8e6c9

Layer	Responsibility	Annotations
Controller	HTTP handling, validation, response mapping	`@RestController`, `@Valid`
Service	Business logic, transactions, orchestration	`@Service`, `@Transactional`
Repository	Data access, queries	`@Repository`, extends `JpaRepository`

@Service
@Transactional(readOnly = true)
public class UserService {
 
 private final UserRepository userRepo;
 private final PasswordEncoder encoder;
 
 @Transactional
 public User create(CreateUserRequest request) {
 if (userRepo.existsByEmail(request.email())) {
 throw new ConflictException("User with email already exists");
 }
 
 var user = new User(request.email(), request.name());
 return userRepo.save(user);
 }
 
 public Optional<User> findById(String id) {
 return userRepo.findById(id);
 }
}

Key Takeaways#

Constructor injection — always; makes dependencies explicit and classes testable
Layered architecture — Controller → Service → Repository (each has one job)
Never expose entities in API responses — use DTOs (records)
@Transactional on service methods — readOnly = true for queries
Profiles separate environment config — @Profile("production") vs @Profile("!production")
Global exception handler (@RestControllerAdvice) centralizes error responses
Spring Data JPA generates repository implementations from method names
Configuration properties (@ConfigurationProperties) for type-safe config binding

Modern Java

Mon, 01 Jan 0001 00:00:00 +0000

Modern Java (17–21+)#

Java has evolved dramatically since version 8. Records, sealed classes, pattern matching, virtual threads, and text blocks make modern Java significantly more concise and expressive than its predecessor. This section covers the features from Java 17 through 21+ that every Java developer should use.

Records (Java 16+)#

Immutable data carriers — a one-line replacement for boilerplate POJOs:

// Before: ~50 lines (fields, constructor, getters, equals, hashCode, toString)
// After:
public record User(long id, String name, String email) {}

var user = new User(1, "Alice", "alice@example.com");
user.name(); // "Alice" (accessor, not getName())
user.toString(); // "User[id=1, name=Alice, email=alice@example.com]"

// Compact constructor (validation)
public record User(long id, String name, String email) {
 public User {
 if (name == null || name.isBlank()) throw new IllegalArgumentException("name required");
 }
}

// Custom methods
public record Point(double x, double y) {
 public double distanceTo(Point other) {
 return Math.sqrt(Math.pow(x - other.x, 2) + Math.pow(y - other.y, 2));
 }
}

When to Use Records#

Use Records	Use Classes
DTOs, value objects	Mutable state
API request/response types	Entities with identity
Configuration objects	Complex inheritance
Event payloads	Builder patterns

Sealed Classes (Java 17+)#

Restrict which classes can extend a type — the algebraic data type equivalent: