Java | Фишки и трюки

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

record Person(String name, String city) {}

public class StreamExample {
    public static void main(String[] args) {
        List<Person> people = List.of(
    new Person("Alice", "New York"),
    new Person("Bob", "Los Angeles"),
    new Person("Charlie", "New York"),
    new Person("David", "Los Angeles"),
    new Person("Edward", "San Francisco")
        );

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

        peopleByCity.forEach((city, peopleInCity) -> {
            System.out.println(city + ": " + peopleInCity.stream()
                    .map(Person::name)
                    .collect(Collectors.joining(", ")));
        });
        // Вывод:
        // San Francisco: Edward
        // New York: Alice, Charlie
        // Los Angeles: Bob, David
    }
}

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence {
    char[] value; // Массив символов, хранящий содержимое строки
    int count;    // Количество символов в текущем объекте StringBuilder
}

public StringBuilder append(String str) {
    if (str == null) str = "null";
    int len = str.length();
    ensureCapacityInternal(count + len); // расширить массив если нужно
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

public class Quest {
    {
        System.out.println(i);
    }
    int i;
    
    public Quest(int i){
        this.i = i;
    }
    
    public static void main(String[] args) {
        new Quest(1);
    }
}

import java.util.Comparator;
import java.util.List;

record Person(String name, int age) {}

public class StreamExample {
    public static void main(String[] args) {
        List<Person> people = List.of(
                new Person("Alice", 30),
                new Person("Bob", 20),
                new Person("Charlie", 40)
        );

        people.stream()
        .max(Comparator.comparingInt(Person::age))
        .ifPresent(person -> System.out.println("Oldest person: " + person.name()));
        // Вывод: Oldest person: Charlie
    }
}

public class Quest {
    
    public static void main(String[] args) {
        System.out.println(condition(null) ? 1 : 2);
    }

    public static boolean condition(Number o) {
        return true;
    }

    public static boolean condition(Long l) {
        return false;
    }

}

~    Побитовый унарный оператор NOT;
&    Побитовый AND;
&=   Побитовый AND с присваиванием;
|    Побитовый OR;
|=   Побитовый OR с присваиванием;
^    Побитовый исключающее XOR;
^=   Побитовый исключающее XOR с присваиванием;
>>   Сдвиг вправо (деление на 2 в степени сдвига);
>>=  Сдвиг вправо с присваиванием;
>>>  Сдвиг вправо без учёта знака;
>>>= Сдвиг вправо без учёта знака с присваиванием;
<<   Сдвиг влево (умножение на 2 в степени сдвига);
<<=  Сдвиг влево с присваиванием.

public class MyClass {
    private int field;

    public MyClass(int field) {
        this.field = field;
    }

    public void method() {
        // some code
    }
}

public abstract class AbstractClass {
    public abstract void abstractMethod();

    public void concreteMethod() {
        // some code
    }
}

public class OuterClass {
    static class StaticNestedClass {
        // some code
    }
}

public class OuterClass {
    class InnerClass {
        // some code
    }
}

public class OuterClass {
    public void method() {
        class LocalClass {
            // some code
        }
        LocalClass local = new LocalClass();
    }
}

public class OuterClass {
    public void method() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // some code
            }
        };
    }
}

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public interface MyInterface {
    void myMethod();
}

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