⌨️ Виртуальные потоки (Virtual Threads) — это новая возможность, представленная в Java, начиная с версии 19 (в предварительном режиме), а окончательно внедрённая в версии 21. Они позволяют создавать и управлять миллионами потоков с минимальными затратами на системные ресурсы. Виртуальные потоки облегчают работу с конкурентными задачами и устраняют необходимость в сложных библиотеках и фреймворках для управления потоками.

Виртуальные потоки гораздо легче системных (они не привязаны к операционной системе), что позволяет их создавать в большом количестве.

Так же, виртуальные потоки совместимы с существующим экосистемой Java, включая традиционные блокирующие операции, такие как I/O.

public class VirtualThreadsExample {
    public static void main(String[] args) throws InterruptedException {
        // Создаем виртуальный поток
        Thread virtualThread = Thread.ofVirtual().start(() -> {
            try {
                // Эмуляция длительной задачи
                Thread.sleep(1000);
                System.out.println("Hello from virtual thread!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // Дожидаемся завершения потока
        virtualThread.join();
    }
}

#java #VirtualThreads

⌨️ Класс Pattern

Pattern - это класс, представляющий собой компилированное представление регулярного выражения. Он позволяет создать объект-шаблон, который можно применить к строке для поиска соответствий определенному шаблону. Для создания объекта Pattern используется статический метод compile(), который принимает на вход строку с регулярным выражением.
Пример создания объекта Pattern:

Pattern pattern = Pattern.compile("\\d");

В примере мы компилируем регулярное выражение, которое соответствует любой цифре в строке. После компиляции мы можем использовать объект Pattern для поиска соответствий в строках. В результате будет выведено количество цифр в строке.

#java #Pattern

⌨️ Создание скриншота

Этот код позволяет сделать снимок экрана и сохранить его в формате .png.

✅Toolkit.getDefaultToolkit().getScreenSize() — для получения размеров экрана;

✅ Robot — объект, который используется для захвата экрана;

✅ BufferedImage — объект, представляющий собой изображение экрана;

✅ ImageIO.write() — метод для сохранения захваченного изображения в файл с заданным именем и форматом.

#Java #Screenshot

⌨️ Каким образом можно создать поток?

✔️ Создать потомка класса Thread и переопределить его метод run();

✔️ Создать объект класса Thread, передав ему в конструкторе экземпляр класса, реализующего интерфейс Runnable. Этот интерфейс содержит метод run(), который будет выполняться в новом потоке. Поток закончит выполнение, когда завершится его метод run().

✔️ Вызвать метод submit() у экземпляра класса реализующего интерфейс ExecutorService, передав ему в качестве параметра экземпляр класса реализующего интерфейс Runnable или Callable (содержит метод call(), в котором описывается логика выполнения).

#java #Thread #Runnable #Callable

⌨️ Инициализация это процесс задания начальных значений переменным и объектам перед их использованием. Этот процесс необходим для того, чтобы обеспечить корректное начальное состояние переменных и объектов в программе.

Порядок инициализации

1⃣ Статические переменные: если в классе есть статические переменные, то они будут инициализированы в первую очередь. Переменные будут инициализированы в том порядке в котором идут в коде.

2⃣ Статический блок инициализации: далее сработает блок инициализации статических переменных.

3⃣ Переменные экземпляра

4⃣ Блок инициализации переменных экземпляра

5⃣ Конструктор

Вывод кода:
Static Variables initialized!
Static Initialization Block initialized!
Instance Variables initialized!
Instance Initialization Block initialized!
Constructor initialized!

Инициализация в Java является важным аспектом, который гарантирует, что объекты и переменные находятся в правильном состоянии перед их использованием. Понимание порядка инициализации помогает избегать ошибок и создавать надежные программы на Java.

⌨️ В чём заключается разница между методами start() и run() класса Thread?

Несмотря на то, что start() вызывает метод run() внутри себя, это не то же самое, что просто вызов run(). Если run() вызывается как обычный метод, то он вызывается в том же потоке и никакой новый поток не запускается, как это происходит, в случае, когда вы вызываете метод start().

#java #Thread #start #run

⌨️ В каких состояниях может находиться поток?

Потоки могут находиться в одном из следующих состояний:

✔️ Новый (New). После создания экземпляра потока, он находится в состоянии Новый до тех пор, пока не вызван метод start(). В этом состоянии поток не считается живым.

✔️ Работоспособный (Runnable). Поток переходит в состояние Работоспособный, когда вызывается метод start(). Поток может перейти в это состояние также из состояния Работающий или из состояния Блокирован. Когда поток находится в этом состоянии, он считается живым.

✔️ Работающий (Running). Поток переходит из состояния Работоспособный в состояние Работающий, когда Планировщик потоков выбирает его как работающий в данный момент.

✔️ Живой, но не работоспособный (Alive, but not runnable). Поток может быть живым, но не работоспособным по нескольким причинам:

▪️Ожидание (Waiting). Поток переходит в состояние Ожидания, вызывая метод wait(). Вызов notify() или notifyAll() может перевести поток из состояния Ожидания в состояние Работоспособный.

▪️Сон (Sleeping). Метод sleep() переводит поток в состояние Сна на заданный промежуток времени в миллисекундах.

▪️Блокировка (Blocked). Поток может перейти в это состояние, в ожидании ресурса, такого как ввод/вывод или из-за блокировки другого объекта. В этом случае поток переходит в состояние Работоспособный, когда ресурс становится доступен.

▪️Мёртвый (Dead). Поток считается мёртвым, когда его метод run() полностью выполнен. Мёртвый поток не может перейти ни в какое другое состояние, даже если для него вызван метод start().

#java #Thread #state

⌨️ Срезы в стримах. Метод takeWhile

В Java 9 появилось два новых метода, полезных для выбора элементов потока с хорошей производительностью: takeWhile и dropWhile.

Допустим, у нас есть следующий список блюд:

List<Dish> specialMenu = Arrays.asList(
new Dish("seasonal fruit", 120),
new Dish("prawns", 300),
new Dish("rice", 350),
new Dish("chicken", 400),
new Dish("french fries", 530));

Для получения блюд с калорийностью меньше 320, можно воспользоваться операцией filter. Недостаток операции filter в том, что она требует прохода в цикле по всему потоку данных с применением предиката ко всем элементам.

В нашем примере список уже отсортирован по числу калорий. Вместо того, чтобы пройтись по каждому элементу, можно прекратить работу сразу же после обнаружения блюда, содержащего 320 калорий или более. В случае небольшого списка это может показаться не таким уж громадным преимуществом, но при работе с потенциально большим потоком элементов окажется весьма полезным.

Поможет нам в этом операция takeWhile! Она позволяет выполнить срез любого потока данных (даже бесконечного) с помощью предиката. И, к счастью, она прекращает работу сразу же по обнаружении неподходящего элемента. Вот как ее следует использовать:

List<Dish> sliceMenu1 
    = specialMenu.stream()
                 .takeWhile(dish -> dish.getCalories() < 320)
                 .collect(toList());

#java #stream #takeWhile

⌨️ Срезы в стримах. Метод dropWhile

Операция dropWhile служит дополнением к операции takeWhile. Она отбрасывает первые элементы, для которых предикат возвращает true. Как только результат вычисления предиката становится ложным, она прекращает работу и возвращает все оставшиеся элементы, причем работает даже в том случае, если число оставшихся элементов бесконечно!

List<Integer> ints = List.of(1,2,3,4,5,6,7,8,9);
ints.stream()
    .dropWhile(i -> i < 5)
    .forEach(System.out::println);
// 5 6 7 8 9

#java #stream #dropWhile

⌨️ Усечение потока данных. Метод limit

Потоки данных поддерживают метод limit(n). Он возвращает еще один поток, не превышающий заданную длину, переданную в limit в виде аргумента. Если поток данных упорядоченный, возвращаются первые элементы, но не более чем n.

Например, с помощью следующего кода можно создать List, выбрав первые три блюда, содержащие более 300 калорий:

List<Dish> dishes = specialMenu
    .stream()
    .filter(dish -> dish.getCalories() > 300)
    .limit(3)
    .collect(toList());

Метод limit работает и для неупорядоченных потоков данных (например, когда источник представляет собой объект типа Set). В этом случае не следует исходить из допущения о какой-либо упорядоченности результата, возвращенного методом limit.

#java #stream #limit

⌨️ Классы-обёртки (wrapper classes)

В Java классы-обёртки (wrapper classes) используются для того, чтобы представлять примитивные типы данных как объекты. Это необходимо, так как Java — это объектно-ориентированный язык, и в некоторых случаях, например, при работе с коллекциями, нужно использовать объекты вместо примитивных типов. Для каждого примитивного типа данных существует соответствующий класс-обёртка.

Java автоматически преобразует примитивные типы в соответствующие объекты классов-обёрток и наоборот. Это упрощает код, так как программисту не нужно делать это вручную.

Все классы-обёртки являются неизменяемыми, то есть их значения не могут быть изменены после создания.

Некоторые классы-обёртки, такие как Byte, Short, Integer и Long, кэшируют значения в определённом диапазоне (от -128 до 127), что улучшает производительность при частом использовании этих значений.

#java #wrappers

⌨️ "Распрямление" потока. Метод flatMap

Метод Stream.flatMap используется для преобразования элементов одного потока (stream) в несколько элементов другого потока, а затем объединения этих элементов в один поток. Это особенно полезно, когда у вас есть коллекция коллекций, и вы хотите "распрямить" её, т.е. получить плоскую структуру, содержащую все элементы.

Допустим, у вас есть список строк, каждая из которых содержит несколько слов, и вы хотите получить поток всех слов:

List<String> sentences = Arrays.asList("Java is fun", "I love programming");

Stream<String> wordsStream = sentences.stream()
    .flatMap(sentence -> Arrays.stream(sentence.split(" "))); // Преобразуем в поток слов

wordsStream.forEach(System.out::println);

Результат:

Java
is
fun
I
love
programming

Здесь каждый массив слов был преобразован в поток, а затем flatMap "распрямил" эти потоки в один.

#java #stream #flatMap

⌨️ Чем отличаются методы Stream.toList() и Stream.collect(Collectors.toList())?

Методы Stream.toList() и Stream.collect(Collectors.toList()) кажутся схожими, так как оба возвращают список, но есть ключевое отличие: Stream.toList() возвращает неизменяемый список, а Stream.collect(Collectors.toList()) возвращает изменяемый список на базе ArrayList.

#java #stream #toList

⌨️ Чем различаются Thread и Runnable?

Thread - это класс, некоторая надстройка над физическим потоком.

Runnable - это интерфейс, представляющий абстракцию над выполняемой задачей.

Интерфейс Runnable позволяет логически отделить логику выполнения задачи от непосредственного управления потоком.

#java #Thread #Runnable