Devops Monk

// Java 7: sort a list of strings by length
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
});

// Run in a new thread
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello from thread");
    }
}).start();

names.sort((a, b) -> Integer.compare(a.length(), b.length()));

new Thread(() -> System.out.println("Hello from thread")).start();

Runnable r = () -> System.out.println("Hello");

Consumer<String> print = s -> System.out.println(s);
// equivalent
Consumer<String> print2 = (s) -> System.out.println(s);
// with explicit type
Consumer<String> print3 = (String s) -> System.out.println(s);

Comparator<String> byLength = (a, b) -> Integer.compare(a.length(), b.length());

Comparator<String> complex = (a, b) -> {
    int lenDiff = Integer.compare(a.length(), b.length());
    if (lenDiff != 0) return lenDiff;
    return a.compareTo(b);
};

Function<Integer, Integer> square = n -> n * n;

// Target type is Runnable — lambda must match void run()
Runnable r = () -> System.out.println("Hi");

// Target type is Callable<String> — lambda must match String call()
Callable<String> c = () -> "Hello";

// Target type is Comparator<String> — lambda must match int compare(String, String)
Comparator<String> cmp = (a, b) -> a.compareTo(b);

// Both have signature: () -> void — same lambda body, different target types
Runnable runnable = () -> System.out.println("x");
Executor executor = cmd -> cmd.run();  // different, but same body works for both

String prefix = "Hello, ";

// OK: prefix is effectively final — never reassigned
Consumer<String> greet = name -> System.out.println(prefix + name);

prefix = "Hi, ";  // COMPILE ERROR: variable used in lambda must be effectively final

public class Counter {
    private int count = 0;  // instance field — heap allocated

    public Runnable makeIncrementer() {
        return () -> count++;  // OK: capturing instance field
    }
}

List<Runnable> tasks = new ArrayList<>();
for (int i = 0; i < 5; i++) {
    final int taskId = i;  // must copy to effectively-final variable
    tasks.add(() -> System.out.println("Task " + taskId));
}
tasks.forEach(Runnable::run);
// Prints: Task 0, Task 1, Task 2, Task 3, Task 4

Runnable a = () -> System.out.println("x");
Runnable b = () -> System.out.println("x");

// This may be true OR false — undefined behaviour
System.out.println(a == b);

// Never use lambdas as map keys or in sets that rely on identity

Predicate<String> nonEmpty = s -> !s.isEmpty();
Predicate<String> longEnough = s -> s.length() > 5;

// Compose: AND
Predicate<String> valid = nonEmpty.and(longEnough);

// Compose: OR
Predicate<String> acceptable = nonEmpty.or(longEnough);

// Negate
Predicate<String> empty = nonEmpty.negate();

Function<Integer, Integer> doubleIt = x -> x * 2;
Function<Integer, Integer> addThree = x -> x + 3;

// andThen: doubleIt first, then addThree
Function<Integer, Integer> doubleThenAdd = doubleIt.andThen(addThree);
// doubleThenAdd.apply(5) == 13

// compose: addThree first, then doubleIt
Function<Integer, Integer> addThenDouble = doubleIt.compose(addThree);
// addThenDouble.apply(5) == 16

List<Person> people = ...;

// Sort by last name, then first name, then age descending
Comparator<Person> order = Comparator
    .comparing(Person::getLastName)
    .thenComparing(Person::getFirstName)
    .thenComparingInt(Person::getAge).reversed();

people.sort(order);

// Before
executor.submit(new Runnable() { public void run() { doWork(); } });

// After
executor.submit(() -> doWork());

// Before
Future<Result> f = executor.submit(new Callable<Result>() {
    public Result call() throws Exception { return compute(); }
});

// After
Future<Result> f = executor.submit(() -> compute());

// Before
Collections.sort(items, new Comparator<Item>() {
    public int compare(Item a, Item b) { return a.getName().compareTo(b.getName()); }
});

// After
items.sort(Comparator.comparing(Item::getName));

// Interface
interface TaxCalculator {
    double calculate(double amount);
}

// Java 7: create an anonymous class per strategy
TaxCalculator uk = new TaxCalculator() {
    public double calculate(double amount) { return amount * 0.20; }
};

// Java 8: lambda directly
TaxCalculator uk = amount -> amount * 0.20;
TaxCalculator us = amount -> amount * 0.08;

// WRONG: list is mutated inside the lambda — side-effectful, hard to reason about
List<String> results = new ArrayList<>();
names.stream().filter(s -> s.length() > 3).forEach(s -> results.add(s));

// RIGHT: use collect
List<String> results = names.stream()
    .filter(s -> s.length() > 3)
    .collect(Collectors.toList());

// COMPILE ERROR: Files.readAllBytes throws IOException
List<byte[]> bytes = paths.stream()
    .map(p -> Files.readAllBytes(p))  // IOException not handled
    .collect(Collectors.toList());

// Fix option 1: wrap in unchecked
List<byte[]> bytes = paths.stream()
    .map(p -> {
        try { return Files.readAllBytes(p); }
        catch (IOException e) { throw new UncheckedIOException(e); }
    })
    .collect(Collectors.toList());

// Fix option 2: extract to a helper
private static byte[] readBytes(Path p) {
    try { return Files.readAllBytes(p); }
    catch (IOException e) { throw new UncheckedIOException(e); }
}
// Then: .map(this::readBytes)

// Ambiguous if execute(Runnable) and execute(Callable<Void>) both exist
execute(() -> doWork());  // COMPILE ERROR: ambiguous

// Fix: cast or use explicit type
execute((Runnable) () -> doWork());