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);
Но важно, чтобы метод корректно это обрабатывал.

public class Task240625 {
    public static void main(String[] args) {
        String s = null;
        s = s + "Java";
        System.out.println(s);
    }
}

<properties>
  <java.version>11</java.version>
  <spring.version>5.3.10</spring.version>
</properties>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>${spring.version}</version>
</dependency>

mvn clean install -Djava.version=17

<dependency>
  <groupId>org.example</groupId>
  <artifactId>lib-a</artifactId>
  <version>1.0</version>
  <exclusions>
    <exclusion>
      <groupId>org.unwanted</groupId>
      <artifactId>unwanted-lib</artifactId>
    </exclusion>
  </exclusions>
</dependency>

mvn dependency:tree

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.10</version>
    </dependency>
  </dependencies>
</dependencyManagement>

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>3.8.1</version>
  <configuration>
    <source>11</source>
    <target>11</target>
  </configuration>
</plugin>

<profiles>
  <profile>
    <id>dev</id>
    <properties>
      <env>development</env>
    </properties>
  </profile>
  <profile>
    <id>prod</id>
    <properties>
      <env>production</env>
    </properties>
  </profile>
</profiles>

<repositories>
  <repository>
    <id>custom-repo</id>
    <url>https://repo.example.com</url>
  </repository>
</repositories>

<parent>
  <groupId>com.example</groupId>
  <artifactId>parent-project</artifactId>
  <version>1.0</version>
</parent>

import java.util.function.Consumer;

public class Task250625 {
    public static void main(String[] args) {
        Consumer<String> c1 = s -> System.out.print("A" + s);
        Consumer<String> c2 = s -> System.out.print("B" + s);
        
        c1.andThen(c2).accept("1");
        c2.andThen(c1).accept("2");
    }
}

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);
}