var message = "Hello, Java!"; // Компилятор автоматически определит тип String
var number = 42; // int
var list = List.of("A", "B", "C"); // List<String>

var x; // Ошибка, требуется инициализация

public record Person(String name, int age) {}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        System.out.println(person); // Person[name=Alice, age=30]
    }
}

import java.lang.ref.WeakReference;

public class WeakRefExample {
    public static void main(String[] args) {
        String str = new String("WeakReference");
        WeakReference<String> weakRef = new WeakReference<>(str);
        str = null; // Теперь объект доступен для GC
        System.gc();
        System.out.println(weakRef.get()); // Может быть null
    }
}

import java.util.concurrent.CompletableFuture;

public class AsyncExample {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> "Hello, Async!")
                .thenAccept(System.out::println);
    }
}

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

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class SumTask extends RecursiveTask<Integer> {
    private final int[] array;
    private final int start, end;
    private final int threshold = 10;

    public SumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= threshold) {
            // Базовый случай: небольшая задача
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // Разделяем задачу
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(array, start, mid);
            SumTask rightTask = new SumTask(array, mid, end);
            
            leftTask.fork(); // Асинхронно запускаем левую подзадачу
            int rightResult = rightTask.compute(); // Синхронно вычисляем правую подзадачу
            int leftResult = leftTask.join(); // Ждем завершения левой подзадачи
            
            return leftResult + rightResult;
        }
    }
}

public class ForkJoinExample {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        SumTask task = new SumTask(array, 0, array.length);
        int result = pool.invoke(task);
        System.out.println("Сумма: " + result);
    }
}

Set<Integer> hashSet = new HashSet<>(Set.of(3, 1, 2)); // [3, 1, 2] (порядок может быть разным)
Set<Integer> treeSet = new TreeSet<>(Set.of(3, 1, 2)); // [1, 2, 3] (отсортировано)

class Person implements Cloneable {
    String name;

    Person(String name) {
        this.name = name;
    }

    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

import java.io.*;

public class DeepCopyExample {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        Person deepCopy = deepCopy(person);
        
        System.out.println("Original: " + person.getName() + ", " + person.getAge());
        System.out.println("Deep copy: " + deepCopy.getName() + ", " + deepCopy.getAge());
    }
    
    public static <T extends Serializable> T deepCopy(T object) {
        try {
            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteOutputStream);
            objectOutputStream.writeObject(object);
            
            ByteArrayInputStream byteInputStream = new ByteArrayInputStream(byteOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteInputStream);
            T copy = (T) objectInputStream.readObject();
            
            return copy;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

class Person implements Serializable {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

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

List<String> list = new ArrayList<>(); // По умолчанию – 10 элементов
for (int i = 0; i < 1000000; i++) {
    list.add("data");
}

List<String> list = new ArrayList<>(1000000);

Map<String, String> map = new HashMap<>(1000000, 0.9f);

List<String> list = new LinkedList<>();
list.get(5000); // O(n)

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
numbers.stream()
       .takeWhile(n -> n < 4)
       .forEach(System.out::println); // 1, 2, 3

String result = switch (day) {
    case "Monday", "Tuesday" -> "Рабочий день";
    case "Saturday", "Sunday" -> "Выходной";
    default -> "Неизвестный день";
};

System.out.println(result);

List<String> list = new ArrayList<>(List.of("A", "B", "A")); // [A, B, A]
Set<String> set = new HashSet<>(Set.of("A", "B", "A")); // [A, B]
Map<Integer, String> map = new HashMap<>(Map.of(1, "One", 2, "Two")); // {1=One, 2=Two}

String json = """
    {
        "name": "Alice",
        "age": 30
    }
    """;

System.out.println(json);

import java.util.List;

public class WildcardExample {
    public static void printList(List<?> list) {
        for (Object element : list) { // Элементы можно читать как Object
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<String> strList = List.of("A", "B", "C");

        printList(intList); // Вывод: 1 2 3
        printList(strList); // Вывод: A B C
    }
}

public static void addElement(List<?> list) {
    // list.add("Hello"); // Ошибка компиляции!
}

import java.util.List;

public class WildcardExample {
    public static double sumNumbers(List<? extends Number> list) {
        double sum = 0;
        for (Number num : list) {
            sum += num.doubleValue();
        }
        return sum;
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<Double> doubleList = List.of(1.1, 2.2, 3.3);

        System.out.println(sumNumbers(intList)); // Вывод: 6.0
        System.out.println(sumNumbers(doubleList)); // Вывод: 6.6
    }
}

import java.util.List;
import java.util.ArrayList;

public class WildcardExample {
    public static void addNumbers(List<? super Integer> list) {
        list.add(10);
        list.add(20);
    }

    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        addNumbers(numberList);
        System.out.println(numberList); // Вывод: [10, 20]
    }
}

import java.util.Formatter;

public class FormatterExample {
    public static void main(String[] args) {
        try (Formatter formatter = new Formatter()) {
            formatter.format("Привет, %s! Тебе %d лет.", "Андрей", 25);
            System.out.println(formatter);
            // Привет, Андрей! Тебе 25 лет.
        }
    }
}

import java.io.FileNotFoundException;
import java.util.Formatter;

public class FileWriteExample {
    public static void main(String[] args) throws FileNotFoundException {
        try (Formatter formatter = new Formatter("output.txt")) {
            formatter.format("Имя: %s, Возраст: %d%n", "Алиса", 30);
        }
    }
}

ThreadLocal<MyClass> threadLocal = ThreadLocal.withInitial(MyClass::new);

try {
    MyClass obj = threadLocal.get();
    // Логика
} finally {
    threadLocal.remove(); // Очищаем объект
}

int[] sum = {0};
list.parallelStream().forEach(i -> sum[0] += i); // Потенциальная ошибка!

int sum = list.parallelStream().reduce(0, Integer::sum);