⌨️ Срезы в стримах. Метод 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

⌨️ Интерфейс CharSequence

Интерфейс CharSequence представляет собой последовательность символов и является базовым интерфейсом для работы с различными строковыми типами. Он был введён в Java начиная с версии 1.4 и служит для предоставления общего интерфейса для объектов, которые могут быть представлены как последовательность символов.

CharSequence реализован такими классами, как:
String — неизменяемая строка.
StringBuilder — изменяемая последовательность символов.
StringBuffer — изменяемая, но потокобезопасная последовательность символов.

CharSequence определяет несколько методов, которые предоставляют доступ к символам последовательности и информации о ней:

int length();

Возвращает количество символов в последовательности.

char charAt(int index);

Возвращает символ по указанному индексу.

CharSequence subSequence(int start, int end);

Возвращает новую последовательность символов, которая является подстрокой оригинальной последовательности. Индекс start включается, а end — нет.

String toString();

Возвращает строковое представление последовательности символов.

CharSequence cs = "Hello, World!";
System.out.println("Length: " + cs.length());
System.out.println("Char at index 1: " + cs.charAt(1));
System.out.println("Subsequence (0, 5): " + cs.subSequence(0, 5));
System.out.println("String: " + cs.toString());

Вывод:

Length: 13
Char at index 1: e
Subsequence (0, 5): Hello
String: Hello, World!

#java #CharSequence

⌨️ Пропуск элементов потока. Метод skip

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

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

List<Dish> dishes = menu
    .stream()
    .filter(d -> d.getCalories() > 300)
    .skip(2)
    .collect(toList());

#java #stream #skip

⌨️ Вчера вышла Java 23

Внутри много интересного, например Markdown документация, поддержка примитивных типов в паттернах и операторах instanceof / switch и многое другое.

Появился еще один тип классов - неявный, как будто существующих нам было мало 😁

Теперь приложение может стартовать даже если метод main не статический и не содержит параметр String[] args:

// --enable-preview --source 23
class HelloWorld {
    void main() {
        System.out.println("Hello, World!");
    }
}

В таком случае во время запуска JVM сама создаст экземпляр класса HelloWorld и вызовет у него метод main():

$ java --enable-preview --source 23 HelloWorld.java
Hello, World!

И даже вот так!:

// HelloWorld.java

String greeting = "Hello, World!";

void main() {
    println(greeting);
}

То есть вообще не объявляя класса! В таком случае виртуальная машина сама объявит неявный класс, в который поместит метод main() и другие верхнеуровневые объявления в файле. Фишка здесь еще и в том что используется метод println() вместо System.out.println(), это возможно из-за того что в неявный класс по умолчанию импортируется новый класс java.io.IO, в котором есть соответствующий метод.

Подробнее можно почитать на Habr'е.

#java23

💎 Проблема ромба (Diamond problem)

Ромбовидное наследование (diamond inheritance) — ситуация в объектно-ориентированных языках программирования с поддержкой множественного наследования, когда два класса B и C наследуют от A, а класс D наследует от обоих классов B и C. При этой схеме наследования может возникнуть неоднозначность: если объект класса D вызывает метод, определенный в классе A (и этот метод не был переопределен в классе D), а классы B и C по-своему переопределили этот метод, то от какого класса его наследовать: B или C?

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

#java #diamond #problem

⌨️ Метод Stream.anyMatch

Метод anyMatch служит для ответа на вопрос: «Удовлетворяет ли заданному предикату хотя бы один элемент из потока данных?»

Метод anyMatch возвращает boolean, а значит, является завершающей (терминальной) операцией.

int[] digits = {1, 3, 5, 7, 2, 9};
boolean result = Arrays.stream(digits).anyMatch(d -> d % 2 == 0);
System.out.println(result); // true

#java #Stream #anyMatch