public class App {
 public static void main(String[] args) {
 System.out.println("Hello");
 }
}

String a = new String("hi");
String b = new String("hi");
System.out.println(a == b); // false
System.out.println(a.equals(b)); // true

package com.example.app;

import java.util.List;
import java.util.*;

class Point {
 int x;
 Point(int x) { this.x = x; }
}

class Dog extends Animal {
 Dog() { super(); }
 void sound() { super.sound(); System.out.println("Bark"); }
}

public static void main(String[] args) {
 System.out.println(args[0]);
}

class Counter {
 static int count = 0;
 Counter() { count++; }
}

static final double PI = 3.14159;

if (obj instanceof String) { String s = (String) obj; }

int i = 5;
int a = ++i; // a=6, i=6
int b = i++; // b=6, i=7

int max = (a > b) ? a : b;

for (int num : numbers) {
 System.out.println(num);
}

switch (day) {
 case 1: System.out.println("Mon"); break;
 default: System.out.println("Other");
}

public class Account {
 private double balance;
 public double getBalance() { return balance; }
 public void deposit(double amt) { balance += amt; }
}

class Animal { void eat() {} }
class Dog extends Animal {}

void print(int a) {}
void print(String s) {}
void print(int a, int b) {}

class Animal { void sound() { System.out.println("..."); } }
class Cat extends Animal { @Override void sound() { System.out.println("Meow"); } }

class Box {
 Box() {}
 Box(int size) {}
}

@Override
public String toString() { return "Point(" + x + ", " + y + ")"; }

try {
 int result = 10 / 0;
} catch (ArithmeticException e) {
 System.out.println(e.getMessage());
} finally {
 System.out.println("Done");
}

Collections.sort(names);
names.sort(Comparator.reverseOrder());

String a = "hi";
String b = new String("hi");
System.out.println(a.equals(b)); // true

int n = Integer.parseInt("42");
String s = String.valueOf(42);

String[] parts = "a,b,c".split(",");

String s = "hello"; s.length(); // 5
int[] arr = new int[5]; arr.length; // 5

int[][] matrix = new int[3][3];
int[][] grid = {{1,2},{3,4}};

int[] nums = {5,3,1,4};
Arrays.sort(nums);

String reversed = new StringBuilder("hello").reverse().toString();

class MyThread extends Thread {
 public void run() { System.out.println("Running"); }
}
class MyTask implements Runnable {
 public void run() { System.out.println("Running"); }
}
new Thread(new MyTask()).start();

String[] arr = list.toArray(new String[0]);
List<String> list2 = Arrays.asList(arr);

Integer boxed = 10; // autoboxing
int unboxed = boxed; // unboxing

int i = 100;
long l = i; // widening
int j = (int) 3.99; // narrowing, j = 3

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");

var list = new ArrayList<String>(); // inferred as ArrayList<String>

int numLetters = switch (day) {
 case MONDAY, FRIDAY -> 6;
 case TUESDAY -> 7;
 default -> 0;
};

outer:
for (int i = 0; i < 3; i++) {
 for (int j = 0; j < 3; j++) {
 if (j == 1) break outer;
 }
}

Animal a = new Dog();
a.sound(); // calls Dog's overridden method

abstract class Shape {
 abstract double area();
 void describe() { System.out.println("A shape"); }
}

interface Drawable {
 void draw();
}
class Circle implements Drawable {
 public void draw() { System.out.println("Drawing circle"); }
}

interface Vehicle {
 default void honk() { System.out.println("Beep"); }
}

@FunctionalInterface
interface Calculator {
 int operate(int a, int b);
}

final class Utility {}
class Base { final void init() {} }
final int MAX = 100;

class Engine {}
class Car {
 private Engine engine = new Engine(); // composition
}

class Outer {
 static class StaticNested {}
 class Inner {}
}

Runnable r = new Runnable() {
 public void run() { System.out.println("Running"); }
};

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
 System.out.println(br.readLine());
}

class InsufficientFundsException extends Exception {
 public InsufficientFundsException(String message) { super(message); }
}

void withdraw(double amt) throws InsufficientFundsException {
 if (amt > balance) throw new InsufficientFundsException("Not enough");
}

try {
 // risky code
} catch (IOException | SQLException e) {
 e.printStackTrace();
}

class Person implements Comparable<Person> {
 public int compareTo(Person p) { return this.age - p.age; }
}
Comparator<Person> byName = (p1, p2) -> p1.name.compareTo(p2.name);

Iterator<String> it = list.iterator();
while (it.hasNext()) {
 String s = it.next();
 if (s.isEmpty()) it.remove();
}

List<String> immutable = List.of("a", "b", "c");

List<String> names = new ArrayList<>();
names.add("Alice"); // compile-time type checked

public static <T extends Comparable<T>> T max(T a, T b) {
 return a.compareTo(b) > 0 ? a : b;
}

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

StringBuilder sb = new StringBuilder();
for (String s : items) sb.append(s);

int[] copy = Arrays.copyOf(original, original.length);

String s = String.format("%s is %d years old", "Tom", 25);

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

ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(() -> System.out.println("Task running"));
executor.shutdown();

Callable<Integer> task = () -> 42;
Future<Integer> future = executor.submit(task);

List<String> lines = Files.readAllLines(Paths.get("data.txt"));

Files.write(Paths.get("out.txt"), "Hello".getBytes());

class User implements Serializable {
 private String name;
}

private transient String password;

try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("log.txt"))) {
 writer.write("Log entry");
}

Runnable r = () -> System.out.println("Hello");
Comparator<Integer> cmp = (a, b) -> a - b;

List<Integer> result = numbers.stream()
 .filter(n -> n % 2 == 0)
 .map(n -> n * n)
 .collect(Collectors.toList());

Optional<String> name = Optional.ofNullable(getName());
name.ifPresent(System.out::println);

list.forEach(System.out::println);
list.sort(String::compareTo);

String joined = names.stream().collect(Collectors.joining(", "));

Supplier<String> sup = () -> "Hello";
Consumer<String> con = System.out::println;
Function<Integer,Integer> square = n -> n * n;
Predicate<Integer> isEven = n -> n % 2 == 0;

public record Point(int x, int y) {}

if (obj instanceof String s) {
 System.out.println(s.length());
}

String html = """
 <html>
 <body>Hello</body>
 </html>
 """;

public class Config {
 private static Config instance;
 private Config() {}
 public static synchronized Config getInstance() {
 if (instance == null) instance = new Config();
 return instance;
 }
}

Pizza pizza = new Pizza.Builder().size(12).addTopping("cheese").build();

@Override
public String toString() { return "Custom"; }

enum Day { MONDAY, TUESDAY, WEDNESDAY }
Day today = Day.MONDAY;

public static int sum(int... numbers) {
 int total = 0;
 for (int n : numbers) total += n;
 return total;
}

Objects.requireNonNull(name, "Name must not be null");

try (Connection conn = DriverManager.getConnection(url, user, pass);
 PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?")) {
 stmt.setInt(1, 5);
 ResultSet rs = stmt.executeQuery();
}

PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE email = ?");
stmt.setString(1, email);

conn.setAutoCommit(false);
try {
 // multiple statements
 conn.commit();
} catch (SQLException e) {
 conn.rollback();
}

List<Integer> unique = list.stream().distinct().collect(Collectors.toList());

list.sort(Comparator.comparing(Person::getAge).thenComparing(Person::getName));

public final class Point {
 private final int x, y;
 public Point(int x, int y) { this.x = x; this.y = y; }
 public int getX() { return x; }
}

class Outer {
 static class Nested {}
}
Outer.Nested obj = new Outer.Nested();

for (Map.Entry<String, Integer> entry : map.entrySet()) {
 System.out.println(entry.getKey() + "=" + entry.getValue());
}

try {
 // code
} catch (SQLException e) {
 throw new RuntimeException("Query failed", e);
}

void printList(List<? extends Number> list) {
 for (Number n : list) System.out.println(n);
}

private volatile boolean running = true;

CompletableFuture.supplyAsync(() -> compute())
 .thenApply(result -> result * 2)
 .thenAccept(System.out::println);

AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();

List<List<Integer>> nested = List.of(List.of(1,2), List.of(3,4));
List<Integer> flat = nested.stream().flatMap(List::stream).collect(Collectors.toList());

list.parallelStream().forEach(System.out::println);

public sealed interface Shape permits Circle, Square {}

Class<?> clazz = Class.forName("com.example.User");
Method[] methods = clazz.getDeclaredMethods();

Integer a = 100, b = 100;
System.out.println(a == b); // true (cached)
Integer c = 200, d = 200;
System.out.println(c == d); // false

class Point implements Cloneable {
 public Point clone() throws CloneNotSupportedException {
 return (Point) super.clone();
 }
}

Map<String, List<Person>> byCity = people.stream()
 .collect(Collectors.groupingBy(Person::getCity));

assert age >= 0 : "Age cannot be negative";