Boolean obj = true;     // упаковка
boolean val = obj;      // распаковка
Также есть кэширование значений: Boolean.TRUE и Boolean.FALSE — это единственные экземпляры класса Boolean, которые обычно и используются.

List<String> names = new ArrayList<>(); // ссылка на объект ArrayList

String a = "Hello";
String b = a;
Обе переменные a и b ссылаются на один и тот же объект "Hello" в куче (heap). Изменение объекта (если он мутабелен) через одну ссылку отразится на другой.

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = list1;
list1.add(10);
System.out.println(list2); // [10]

class User {
    String name;
}

User user1 = new User();
User user2 = user1;
user1 = null; // объект всё ещё доступен через user2

String a = new String("Java");
String b = new String("Java");
System.out.println(a == b);      // false — разные объекты
System.out.println(a.equals(b)); // true — сравнение содержимого
== сравнивает ссылки, а equals() — содержимое (если метод переопределён корректно).

String s = null;
System.out.println(s.length()); // исключение
Поэтому рекомендуется использовать Objects.requireNonNull, Optional, или делать явные проверки на null.

int[] nums = {1, 2, 3};
System.out.println(nums.length); // 3
Массивы имеют поля и методы (length — поле, а не метод), и их тип — int[], String[] и т.д.

List<Integer> list = new ArrayList<>();

List<int> wrongList; // ошибка
Поэтому применяются классы-обёртки: Integer, Double, Boolean и т.д.

Person person1 = new Person("John", 25);

Person person1 = new Person("John", 25);
Person person2 = person1;   // person2 ссылается на тот же самый объект
person1 = null;            // теперь единственная ссылка на объект — person2

int[] numbers = new int[5];

String[] names = {"Alice", "Bob", "Charlie"};

int[] data = new int[100];
data = null; // массив станет доступен для удаления

numbers[0] = 10;
System.out.println(numbers[0]); // выводит 10

void fill(int[] arr) {
    arr[0] = 42;
}
После вызова fill(numbers) значение numbers[0] станет 42.

String s1 = "Hello";
String s2 = new String("Hello");

char[] chars = {'J', 'a', 'v', 'a'};
String s3 = new String(chars);

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true — обе ссылаются на одну строку из пула

String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2); // false

String s1 = new String("abc").intern();
String s2 = "abc";
System.out.println(s1 == s2); // true

String s = "Hello, World!";
int length = s.length();
char ch = s.charAt(0);
String lower = s.toLowerCase();
boolean contains = s.contains("World");

String original = "Java";
String modified = original.replace("J", "K");
System.out.println(original); // Java
System.out.println(modified); // Kava

String a = "hello";
String b = new String("hello");

System.out.println(a == b);          // false — разные объекты
System.out.println(a.equals(b));     // true — одинаковое содержимое
Оператор == сравнивает ссылки, а метод equals() — содержимое.

public interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

public interface Logger {
    default void log(String msg) {
        System.out.println("Log: " + msg);
    }
}

public void processAnimal(Animal animal) {
    animal.makeSound(); // работает с любым классом, реализующим Animal
}

@FunctionalInterface
public interface Converter<F, T> {
    T convert(F from);
}

Animal animal = new Dog();

List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
Здесь List и Map — интерфейсы, а ArrayList и HashMap — конкретные реализации. Это позволяет заменить реализацию без изменения остального кода.

var list = new ArrayList<String>();
var name = "John";
var age = 25;

ArrayList<String> list = new ArrayList<>();
String name = "John";
int age = 25;

var name; // ошибка компиляции

var user = new User("Alice");

User user = new User("Alice");

for (var entry : map.entrySet()) {
    ...
}

try (var stream = Files.lines(path)) {
    ...
}

Map<String, List<User>> usersByRole = new HashMap<>();

var usersByRole = new HashMap<String, List<User>>();

for (var entry : map.entrySet()) { ... }

var x = process(); // Что возвращает process()? Map? List? String?

var data = null; // ошибка компиляции: невозможно вывести тип

var list = Arrays.asList(1, 2, 3); // list: List<Integer>, но неизменяемый!

var x = 42; // int
var y = 42L; // long

// Может быть неожиданным, если x и y пойдут в разные ветви перегрузки

var list = new ArrayList<String>(); // тип легко читается

var result = service.process(); // неясно, что такое result

String name = null;

public class Example {
    String name; // По умолчанию null
}

Person person = null;

String userInput = null; // Пользователь ничего не ввёл

if (userInput == null) {
    System.out.println("Пустой ввод");
}

List<String> list = getList();
if (list != null) {
    list.add("new item");
}

String name = null;
System.out.println(name.length()); // NullPointerException

String result = compute();
if (result != null) {
    ...
}
Если забыть такую проверку — возможна ошибка.

Objects.requireNonNull(input, "Input must not be null");

Optional<String> result = Optional.ofNullable(getName());
result.ifPresent(System.out::println);
Optional помогает избежать null, особенно в возвращаемых значениях.

List<String> list = new ArrayList<>(); // вместо null

if (obj == null) { ... }

obj.equals(null); // Может выбросить NPE, если obj == null

String s1 = null;
String s2 = "";
System.out.println(s1 == s2); // false

String s = null;
System.out.println(s instanceof String); // false

printName(null);
Но важно, чтобы метод корректно это обрабатывал.

Integer x = 5; // int -> Integer автоматически

Integer x = Integer.valueOf(5);

int y = x; // Integer -> int автоматически

int y = x.intValue();

int x = 10;
Integer y = new Integer(x); // вручную

x — хранится в стеке, занимает 4 байта.
y — объект в куче, содержит поле типа int со значением 10 и дополнительную информацию (например, hashCode, class pointer и т.д.).

Integer z = 10;
Компилятор заменит это на Integer.valueOf(10), что использует кэш оберток от -128 до 127.

List<Integer> numbers = new ArrayList<>();
numbers.add(10);  // int -> Integer (autoboxing)
int n = numbers.get(0); // Integer -> int (unboxing)
Это работает, потому что ArrayList хранит только объекты, а int автоматически упаковывается и распаковывается.

List<Integer> list = new ArrayList<>();
list.add(42); // без ручного создания new Integer(42)

Integer sum = 0;
for (int i = 0; i < 10; i++) {
    sum += i; // автораспаковка и автоупаковка
}

Integer x = null;
int y = x; // NullPointerException

Integer sum = 0;
for (int i = 0; i < 1000; i++) {
    sum += i; // каждый шаг — распаковка, сложение, упаковка
}

int sum = 0; // быстрее и без накладных расходов

Integer a = 1000;
Integer b = 1000;
System.out.println(a == b); // false

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true — значения из кэша

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true

Integer x = 128;
Integer y = 128;
System.out.println(x == y); // false
Причина — кэш для Integer в диапазоне [-128; 127].

public static Integer valueOf(int i) {
    if (i >= -128 && i <= 127)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}