List<String> list = List.of("Str1", "Str2", "Str3");
String result = list.stream().reduce("", (a, b) -> a + b);
System.out.println(result); // Str1Str2Str3

List<String> list = List.of("Str1", "Str2", "Str3");
String result = list.stream().collect(Collectors.joining());
System.out.println(result); // Str1Str2Str3

// Для импорта конкретного статического члена
import static package.Clazz.member;

// Для импорта всех статических членов класса
import static package.Clazz.*;

public class MathUtils {
    public static final double PI = 3.141592653589793;
    public static int add(int a, int b) {
        return a + b;
    }
    public static int subtract(int a, int b) {
        return a - b;
    }
}

import static MathUtils.PI;
import static MathUtils.add;

public class Main {
    public static void main(String[] args) {
        System.out.println("Value of PI: " + PI);
        System.out.println("Addition result: " + add(5, 3));
    }
}

import static MathUtils.*;

public class Main {
    public static void main(String[] args) {
        System.out.println("Value of PI: " + PI);
        System.out.println("Addition result: " + add(5, 3));
        System.out.println("Subtraction result: " + subtract(5, 3));
    }
}

void method() {
    try {
        //...
    } catch (FileNotFoundException ex) {
        //...
    } catch (IOException ex) {
        //...
    }
}

try {  
    //...
} catch(IOException | SQLException ex) {
    //...
}

try { 
    //код, который потенциально может привести к исключительной ситуации 
} 
catch(SomeException e ) { //в скобках указывается класс конкретной ожидаемой ошибки  
    //код обработки исключительной ситуации
} 
finally {
    //необязательный блок, код которого выполняется в любом случае
}

class Parent { }
class Child extends Parent { }

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Child child = new Child();
        System.out.println(parent instanceof Parent); // true
        System.out.println(child instanceof Parent); // true
        System.out.println(parent.getClass() == Parent.class); // true
        System.out.println(child.getClass() == Parent.class); // false
    }
}

ContainingClass::staticMethodName

import java.util.function.Function;

public class MethodReferenceExample {
    public static void main(String[] args) {
        Function<String, Integer> converter = Integer::parseInt;
        Integer number = converter.apply("123");
        System.out.println(number); // 123
    }
}

containingObject::instanceMethodName

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.forEach(System.out::println);
    }
}

ContainingType::methodName

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        Function<String, Integer> stringLength = String::length;
        Integer length = stringLength.apply("Hello, World!");
        System.out.println(length); // 13
    }
}

ClassName::new

import java.util.function.Supplier;

public class MethodReferenceExample {
    public static void main(String[] args) {
        Supplier<MethodReferenceExample> exampleSupplier = MethodReferenceExample::new;
        MethodReferenceExample example = exampleSupplier.get();
        System.out.println(example); // MethodReferenceExample@<hashcode>
    }
}

🟢При разработке игр на Java требуется работать со звуком и музыкой.

🟢Нужно подключить звуковые звуки (эффекты и музыку) к игровому проекту.

🟢Реализовать звуковой сигнал в нужные моменты (например, выстрел, прыжок, победа).

🟢Обеспечить громкость и возможность паузы/продолжения музыки.

🟢Оптимизировать загрузку и меры для минимизации задержек и нагрузки на систему.

🟢javax.sound.sampled позволяет работать с аудиофайлами формата WAV, AIFF и др.

🟢Например, LWJGL OpenAL , TinySound , JOAL — более мощные и гибкие решения для работы со звуком в играх, 3D-звуке, резервных источниках и других возможностях.

🟢Если используются игровые движки (например, LibGDX), он обычно предоставляет собственный удобный API для работы со звуком.

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;

public class SoundPlayer {

    private Clip clip;

    // Загрузка и подготовка звукового файла
    public void loadSound(String filepath) {
        try {
            AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(new File(filepath));
            clip = AudioSystem.getClip();
            clip.open(audioInputStream);
        } catch (UnsupportedAudioFileException | IOException | LineUnavailableException e) {
            System.err.println("Ошибка загрузки звука: " + e.getMessage());
        }
    }

    // Воспроизведение звука
    public void play() {
        if (clip == null) return;
        if (clip.isRunning()) clip.stop();
        clip.setFramePosition(0);
        clip.start();
    }

    // Остановка звука
    public void stop() {
        if (clip != null && clip.isRunning()) {
            clip.stop();
        }
    }

    // Регулировка громкости (от 0.0 до 1.0)
    public void setVolume(float volume) {
        if (clip == null) return;
        FloatControl gainControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);
        float dB = (float)(Math.log10(volume) * 20);
        gainControl.setValue(dB);
    }

    public static void main(String[] args) {
        SoundPlayer sound = new SoundPlayer();
        sound.loadSound("jump.wav"); // Замените на путь к вашему звуковому файлу
        sound.setVolume(0.5f);
        sound.play();

        // Для демонстрации задержка перед завершением программы
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sound.stop();
    }
}

🟢Сохранить состояние игрового объекта (например, класс Player) в файл.

🟢Загрузить данные из файла при старте игры.

🟢Обеспечить корректную работу даже при изменениях в структуре класса.

🟢Обработать возможные ошибки ввода-вывода.

🟢Класс реализует интерфейс Serializable, и с помощью ObjectOutputStream и ObjectInputStream объекты записываются и читаются из файла.

🟢Сериализация в человекочитаемый формат с помощью библиотек, например, Gson, Jackson (для JSON) или JAXB (для XML). Это удобно для отладки и совместимости.

🟢Реализация собственных методов записи и чтения данных, например, через DataOutputStream/DataInputStream, что даёт больше контроля над форматом и размером файла.

import java.io.*;

class Player implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int level;
    int score;

    public Player(String name, int level, int score) {
        this.name = name;
        this.level = level;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Player{name='" + name + "', level=" + level + ", score=" + score + '}';
    }
}

public class SaveLoadGame {
    public static void savePlayer(Player player, String filename) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename))) {
            oos.writeObject(player);
            System.out.println("Прогресс сохранён.");
        } catch (IOException e) {
            System.err.println("Ошибка при сохранении: " + e.getMessage());
        }
    }

    public static Player loadPlayer(String filename) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename))) {
            return (Player) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("Ошибка при загрузке: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) {
        Player player = new Player("Игрок1", 5, 1500);
        String saveFile = "player.dat";

        savePlayer(player, saveFile);

        Player loadedPlayer = loadPlayer(saveFile);
        if (loadedPlayer != null) {
            System.out.println("Загруженный игрок: " + loadedPlayer);
        }
    }
}

for (initialization; condition; update) {
    // тело цикла
}

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(i + ": " + numbers[i]);
}

for (type element : collection) {
    // тело цикла
}

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println(number);
}

while (condition) {
    // тело цикла
}

String code = UUID.randomUUID().toString();
boolean isCodeExists = repo.isCodeExists(code);
while (isCodeExists) {
    code = UUID.randomUUID().toString();
    isCodeExists = repo.isCodeExists(code);
}
repo.saveCode(code);

do {
    // тело цикла
} while (condition);

String command;
do {
    command = readCommand();
    doCommand(command);
} while (!"EXIT".equals(command));

default <V> Function<V,R> compose(Function<? super V,? extends T> before)
default <V> Function<T,V>   andThen(Function<? super R,? extends V> after)

import java.util.function.Function;

public class ComposeAndThenDemo {
    public static void main(String[] args) {
        Function<String, Integer> parse  = Integer::parseInt;
        Function<Integer, Double> half   = i -> i / 2.0;
        Function<Double, String> toStr   = d -> "Result: " + d;

        // Составляем: сначала parse, затем half, затем toStr
        Function<String, String> pipeline =
            toStr
             .compose(half)      // toStr(half(x))
             .compose(parse);    // toStr(half(parse(x)))

        // То же самое через andThen:
        Function<String, String> pipeline2 =
            parse
             .andThen(half)      // half(parse(x))
             .andThen(toStr);    // toStr(half(parse(x)))

        System.out.println(pipeline.apply("42"));   // Result: 21.0
        System.out.println(pipeline2.apply("42"));  // Result: 21.0
    }
}

interface Example {
    int process(int a);
    default void show() {
        System.out.println("default show()");
    }
}

interface Paper {
    default void show() {
        System.out.println("default show()");
    }
}

class Licence implements Paper {
    public void show() {
        Paper.super.show();
    }
}

interface Paper {
    static void show() {
        System.out.println("static show()");
    }
}

class Licence {
    public void showPaper() {
        Paper.show();
    }
}

String day = "MONDAY";
int numLetters;
switch (day) {
    case "MONDAY":
    case "FRIDAY":
    case "SUNDAY":
        numLetters = 6;
        break;
    case "TUESDAY":
        numLetters = 7;
        break;
    default:
        numLetters = 8;
}
System.out.println(numLetters); // Вывод: 6

String day = "MONDAY";
int numLetters = switch (day) {
    case "MONDAY", "FRIDAY", "SUNDAY" -> 6;
    case "TUESDAY" -> 7;
    default -> 8;
};
System.out.println(numLetters); // Вывод: 6

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

public class StreamCollectorsExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Примеры использования Collectors
        // Преобразование элементов коллекции в строку
        String numbersAsString = numbers.stream()
                                        .map(Object::toString)
                                        .collect(Collectors.joining(", "));
        System.out.println("Числа в виде строки: " + numbersAsString);
        
        // Получение среднего значения всех элементов коллекции
        double average = numbers.stream()
                                 .collect(Collectors.averagingInt(Integer::intValue));
        System.out.println("Среднее значение: " + average);
        
        // Фильтрация элементов и сборка их в новую коллекцию
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(num -> num % 2 == 0)
                                           .collect(Collectors.toList());
        System.out.println("Четные числа: " + evenNumbers);
        
        // Группировка элементов по условию
        System.out.println("Числа по остатку от деления на 3: " + numbers.stream()
                                                                      .collect(Collectors.groupingBy(num -> num % 3)));
    }
}