Java refresher Cheat Sheet (DRAFT) by nixik09

String direction = getDirection(); 
switch (direction) {
    case "left":
        goLeft(); 
        break;
    case "right":
        goRight(); 
        break;
    default: 
        return "unknown";
}

// Java 14+
return switch (shirtNum) {
     case 1 -> "goalie";
     case 2 -> "left back";
     case 3, 4 -> "centre back";
     case 6, 7, 8 -> "midfielder";
     default -> throw new IllegalArgumentException("Invalid shirt number: " + shirtNum);
}

List<Person> people = Arrays.asList(
    new Person("John", 25), 
    new Person("Sarah", 32), 
    new Person("Mike", 17), 
    new Person("Emily", 25)
); 

// Find names of adults, sorted alphabetically
List<String> adultNames = person.stream()
    .filter(person -> person.getAge() >= 18)
    .map(Person::getName)
    .sorted()
    .collect(Collectors.toList()); 

System.out.println(adultNames); // [Emily, John, Sarah]

double averageAge = people.stream()
    .mapToInt(Person::getAge)
    .average()
    .orElse(0.0);

System.out.println("Average age: " + averageAge);

// 1. by inheriting from Thread class
public class ExampleThread extends Thread {
    @Override // note override! invoked when thread starts
    public void run() {  // we do NOT call RUN!!
        // contains all the code to execute when starting thread
        System.out.println(Thread.currentThread().getName());
    }
}

// start new thread..
public class ThreadExamples {
    public static void main(String[] args ) {
        ExampleThread thread = new ExampleThread();
        thread.start(); // only START to start new thread
    }
}

// 2. implementing Runnable interface
public class ExampleRunnable implements Runnable {
    @Override // note OVERRIDE!!
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

public class ThreadExamples {
    public static void main(String[] args) {
        ExampleRunnable runnable = new ExampleRunnable(); 
        Thread thread = new Thread(runnable); 
        thread.start();
    }
}

// 3. Anon declarations
public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()); 
        }); 
        thread.start(); 
    }
}

/** 
Throwing a checked exception
*/
public class InsufficientBalanceException extends Exception {}

public class BankAccount {
    public void withdraw(double amount) throws InsufficientBalanceException {
        if (balance < amount) {
            throw new InsufficientBalanceException(); 
        }
    }

/**
Throwing an unchecked exception
*/
public class BankAccount {
    public void withdraw(double amount) {
        if (amount < 0) {
            throw new IllegalArgumentException("Cannot withdraw a negative amount"); 
        }
    }
}

/** 
try, catch and finally
*/
try {
    bankAccount.withdraw(amount);
} catch (InsufficientBalanceException) {
    System.out.println("Withdrawal failed: insufficient balance");
} catch (RuntimeException e) {
    System.out.println("Withdrawal failed: " + e.getMessage()); 
} finally { 
    System.out.println("Current balance: " + bankAccount.getBalance()); 
}

List<String> fruits = Arrays.asList("apple", "banana", "cherry", "date"); 

// filter - keeps elements that match a predicate 
Stream<String> longFruits = fruits.stream()
    .filter(fruit -> fruit.length() > 5);

// map - transforms each element
Stream<String> fruitLengths = fruits.stream()
    .map(String::length); 

// sorted - sorts elements 
Stream<String> sortedFruits = fruits.stream()
    .sorted(); 

// distinct - removes duplicates 
Stream<String> uniqueFruits = fruits.stream()
    .distinct(); 

// limit - reduces stream size 
Stream<String> limitedFruits = fruits.stream() 
    .limit(2); 

// skip - skips elements 
Stream<String> skippedFruits = fruits.stream()
    .skip(1);

List<String> fruits = Arrays.asList("apple", "banana", "cherry"); 

// forEach - performs actions on each element
fruits.stream().forEach(System.out::println); 

// collect - puts each element into a collection 
List<String> fruitList = fruits.stream()
    .filter(fruit -> fruit.length() > 5) 
    .collect(Collectors.toList()); 

// reduce - reduces stream to single value
Optional<String> combined = fruits.stream()
    .reduce((a, b) -> a + ", " + b); 

// count - returns number of elements
long count = fruits.stream().count(); 

// anyMatch/allMatch/noneMatch - check predicates 
boolean anyLong = fruits.stream()
    .anyMatch(fruit -> fruit.length() > 5); 
boolean allLong = fruits.stream()
    .allMatch(fruit -> fruit.length() > 3); 
boolean noneLong = fruits.stream()
    .noneMatch(fruit -> fruit.length() > 10);

// findFirst/findAny - find elements
Optional<String> first = fruits.stream().findFirst();

- String::length and x::equals - not static methods; equals() and length() are both instance methods. 
- The shorthand forms are method references, equivalent to x -> operation.equals(x) or x->x.length.

//
object::instanceMethod
String prefix = "Hello";
List<String> words = List.of("Hello", "Hi", "Hey"); 
boolean allMatch = words.stream()
    .allMatch(prefix::equals); // same: x -> prefix.equals(x)

//
Class::staticMethod
// Use for static utility methods, like from Math or Integer
List<String> numbers = List.of("1", "2", "3");
List<Integer> ints = numbers.stream()
   .map(Integer::parseInt) // same as: x -> Integer.parseInt(x)
   .toList();

List<Double> values = List.of(9.0, 16.0, 25.0);
List<Double> roots = values.stream()
   .map(Math::sqrt) // same as: x -> Math.sqrt(x)
   .toList();

//
Class::instanceMethod
List<String> items = List.of("Hello", "Hi", "Hey"); 
List<String> lower = items.stream()
   .map(String::toUpperCase) // same as: x -> s -> s.toUpperCase()
   .toList();

List<String> nonEmpty = items.stream()
   .filter(s -> !s.isEmpty()); // classic
// or
List<String> nonEmpty2 = items.stream()
    .filter(Predicate.not(String::isEmpty)) // java 11+
    .toList();

//
Constructor references - ClassName::new
List<String> list = Stream.of("a", "b", "c")
   .collect(Collectors.toCollection(ArrayList::new)); // creates new ArrayList

//
Sorting with method references
List<String> names = List.of("Zoe", "Amy", "John");
List<String> sorted = names.stream()
   .sorted(String::compareToIgnoreCase) // same as (a, b) -> a.compareToIgnoreCase(b)
    .toList();