// Old way
if (s instanceof Rectangle) {
    Rectangle r = (Rectangle) s;
    return 2 * r.length() + 2 * r.width();
}

// New — binding var in instanceof
if (s instanceof Rectangle r) {
    return 2 * r.length() + 2 * r.width();
}

return switch (obj) {
    case Integer i  -> String.format("int %d", i);
    case Long l     -> String.format("long %d", l);
    case Double d   -> String.format("double %f", d);
    case String s   -> String.format("String %s", s);
    case null       -> "It is null";
    default         -> obj.toString();
};

switch (obj) {
    case String s when s.length() == 1
               -> System.out.println("Short: " + s);
    case String s -> System.out.println(s);
    default       -> System.out.println("Not a string");
}

// Verbose if-else chain
if (s instanceof Rectangle r)
    return 2*r.length() + 2*r.width();
else if (s instanceof Circle c)
    return 2*c.radius()*Math.PI;
else throw new IllegalArgumentException(...);

// Clean switch expression
return switch (s) {
    case Rectangle r -> 2*r.length() + 2*r.width();
    case Circle c    -> 2*c.radius()*Math.PI;
    default          -> throw new IllegalArgumentException(...);
};

switch (obj) {
    case String s       -> println("String: " + s);
    case null, default  -> println("null or other");
}

// Generic class
class Test<T, I> { T obj; I obj2; }

// Generic method
class Abc { <T> void func(T elem) { ... } }

// Empty optional
Optional<String> empty = Optional.empty();

// From a non-null value (throws NPE if null)
Optional<String> present = Optional.of("hello");

// From a possibly-null value — safe
Optional<String> maybe = Optional.ofNullable(getValue());

// get() — throws NoSuchElementException if empty; avoid raw get()
String val = opt.get();

// orElse — always evaluates the fallback expression
String val = opt.orElse("default");

// orElseGet — lazy; fallback only called if empty (prefer this)
String val = opt.orElseGet(() -> computeDefault());

// orElseThrow — throws if empty; no-arg = NoSuchElementException
String val = opt.orElseThrow();
String val = opt.orElseThrow(() -> new IllegalStateException("missing"));

// or — returns another Optional if empty (Java 9+)
Optional<String> result = opt.or(() -> Optional.of("fallback"));

// isPresent / isEmpty (Java 11+)
if (opt.isPresent()) { ... }
if (opt.isEmpty())   { ... }

// ifPresent — runs action only if value exists
opt.ifPresent(System.out::println);

// ifPresentOrElse (Java 9+) — branch on presence
opt.ifPresentOrElse(
    val  -> System.out.println("Got: " + val),
    ()   -> System.out.println("Empty")
);

// map — transforms value if present, returns Optional of result
Optional<Integer> len = opt.map(String::length);

// flatMap — use when mapper itself returns an Optional (avoids Optional<Optional<T>>)
Optional<String> city = userOpt.flatMap(u -> u.getAddress())
                                .flatMap(a -> a.getCity());

// filter — keeps value only if predicate matches, else empty
Optional<String> long_ = opt.filter(s -> s.length() > 5);

// stream() (Java 9+) — 0 or 1 element stream; great for flatMap
List<String> names = optionals.stream()
    .flatMap(Optional::stream)   // unwrap all present values
    .toList();

// ❌ Antipattern — just use if-null check instead
if (opt.isPresent()) {
    return opt.get();
} else {
    return "default";
}

// ✅ Use orElse / orElseGet
return opt.orElse("default");

// ❌ Never use Optional as a field or method parameter
// — it's designed as a return type only
class User { Optional<String> nickname; } // bad

// ❌ Don't wrap primitives — use OptionalInt, OptionalLong, OptionalDouble
Optional<Integer> count = ...; // allocates — use OptionalInt instead