Java 8 против Scala, Часть II: API Streams

Это часть 2 статьи. Если вы хотите начать с 1, вы можете нажать  здесь .

Поток против Коллекции?

Давайте начнем с краткого и неполного описания мной :), коллекция — это конечный набор данных, а поток — это последовательный набор значений, который может быть как конечным, так и бесконечным. Да, вот и все.

Streams API — это новый API, который поставляется с Java 8 для управления сбором и потоковой передачей данных. API Streams не изменяет состояние, в то время как API Коллекций. Например, когда вы вызываете  Collections.sort (list) , метод сортирует экземпляр коллекции, который вы передаете через аргумент, в то время как вызов  list.stream (). Sorted ()  дает вам новую копию коллекции и оставляет исходную копию без изменений. Вы можете прочитать больше об API потоков  здесь .

Ниже приведены интересные сравнения коллекций и потоков, которые я скопировал из документации по Java 8. Я настоятельно рекомендую вам прочитать полную версию  здесь .

Потоки отличаются от коллекций несколькими способами:

1. Нет хранения. Поток — это не структура данных, в которой хранятся элементы; вместо этого он передает элементы из источника через конвейер вычислительных операций.
2. Функциональный характер. Операция над потоком дает результат, но не изменяет его источник.
3. Поиск лени. Многие потоковые операции, такие как фильтрация, отображение или удаление дубликатов, могут быть реализованы лениво, открывая возможности для оптимизации.
4. Возможно, неограничен. Хотя коллекции имеют конечный размер, потоки не нужны.
5. Расходные материалы. Элементы потока посещаются только один раз в течение жизни потока.

Java и Scala имеют довольно простой способ одновременного вычисления значений в коллекции. В Java вы просто должны вызывать  ParallelStream () *  или stream () .rallel ()  вместо просто  stream ()  из коллекции. В Scala вы должны вызвать  par ()  перед вызовом других функций. Довольно заманчиво добавить параллелизм и ожидать, что программа будет работать быстрее. К сожалению, большую часть времени он будет работать медленнее. На самом деле, параллелизм — это особенность, которую очень легко реализовать неправильно. Проверьте эту интересную статью:  параллельные потоки Java вредны для вашего здоровья!

* Из Javadoc функция  parallelStream ()  возвращает возможно параллельный поток с коллекцией в качестве источника. Таким образом, он может возвращать последовательный поток. Какие??? ( кто-то исследовал, почему существует этот API )

Java Streams API вычисляет элементы лениво. Это означает, что промежуточные операции не выполняют никакой обработки, пока не будет выполнена терминальная операция. Обработка ленивых потоков может быть оптимизирована для повышения производительности. Например, у нас есть фильтрация, отображение и суммирование в конвейере. Эти операции могут быть объединены в один проход данных, чтобы уменьшить количество промежуточных состояний. Лень также позволяет обрабатывать только те данные, которые необходимы. Напротив, коллекции Scala строго подразумевают, что элемент будет обработан с нетерпением. … Хм … это будет означать, что в нашем тесте Java Streams API будет иметь преимущество перед Scala? Если мы сравним API потоков Java с API коллекций Scala, ответ будет положительным. Но у вас есть так много вариантов в Scala. Вы можете легко преобразовать коллекцию в поток, просто позвонив toStream () . У Scala также есть другая концепция, которая называется View, которая также является нестрогой коллекцией, такой как Stream. Что такое нестрогая коллекция? Это коллекция, которая будет вычисляться лениво, ака. ленивая коллекция.

Давайте кратко рассмотрим функции Stream и View в Scala.

Скала Стрим

Поток Scala немного отличается от потока Java. В потоке Scala вам не нужно вызывать операцию терминала, чтобы получить результат, поскольку потоки являются результатом. Stream — это абстрактный класс, реализующий черты AbstractSeq , LinearSeq и  GenericTraversableTemplate . Таким образом, вы можете относиться к Stream как к Seq .    

def fibFrom(a: Int, b: Int): Stream[Int] = a #:: fibFrom(b, a + b)
val fib1 = fibFrom(0, 1) //0 1 1 2 3 5 8 …
val fib5 = fibFrom(0, 5) //0 5 5 10 15 …
//fib1.force //Don’t do this cause it will call the function infinitely and soon you will get the OutOfMemoryError
//fib1.size //Don’t do this too with the same reason as above.
fib1.take(10) //Do this. It will take the first 10 from the inifite Stream.
fib1.take(20).foreach(println(_)) //Prints 20 first numbers

public class Pet {
    public static enum Type {
        CAT, DOG
    }
    public static enum Color {
        BLACK, WHITE, BROWN, GREEN
    }
    private String name;
    private Type type;
    private LocalDate birthdate;
    private Color color;
    private int weight;
    ...
}

//Before Java 8
List<Pet> tmpList = new ArrayList<>();
for(Pet pet: pets){
    if(pet.getBirthdate().isBefore(LocalDate.of(2013, Month.JANUARY, 1))
            && pet.getWeight() > 50){
        tmpList.add(pet);
    }
}

//Java 8 - Stream
pets.stream()
    .filter(pet -> pet.getBirthdate().isBefore(LocalDate.of(2013, Month.JANUARY, 1)))
    .filter(pet -> pet.getWeight() > 50)
    .collect(toList())

//Java 8 - Collection
pets.removeIf(pet -> !(pet.getBirthdate().isBefore(LocalDate.of(2013, Month.JANUARY, 1))
                    && pet.getWeight() > 50));
//Applying De-Morgan's law.
pets.removeIf(pet -> pets.get(0).getBirthdate().toEpochDay() >= LocalDate.of(2013, Month.JANUARY, 1).toEpochDay()
                || pet.getWeight() <= 50);

//Scala - strict collection
pets.filter { pet => pet.getBirthdate.isBefore(LocalDate.of(2013, Month.JANUARY, 1))}
.filter { pet => pet.getWeight > 50 } //List[Pet]
//Scala - non-strict collection
pets.views.filter { pet => pet.getBirthdate.isBefore(LocalDate.of(2013, Month.JANUARY, 1))}
.filter { pet => pet.getWeight > 50 } //SeqView[Pet]
//Scala - stream
pets.toStream.filter { pet => pet.getBirthdate.isBefore(LocalDate.of(2013, Month.JANUARY, 1))}
.filter { pet => pet.getWeight > 50 } //Stream[Pet]

//Java approach
Map<Pet.Type, List<Pet>> result = pets.stream().collect(groupingBy(Pet::getType));

//Scala approach
val result = pets.groupBy(_.getType)

//Java approach
pets.stream().sorted(comparing(Pet::getType)
    .thenComparing(Pet::getName)  
    .thenComparing(Pet::getColor))
    .collect(toList());

//Scala approach
pets.sortBy{ p => (p.getType, p.getName, p.getColor) }

//Java approach
pets.stream().map( p-> 
        String.format(“%s — name: %s, color: %s”, 
            p.getType(), p.getName(), p.getColor())
    ).collect(toList());

//Scala approach
pets.map{ p => s"${p.getType} - name: ${p.getName}, color: ${p.getColor}"}

//Java approach
pets.stream()
    .filter( p-> p.getName().equals(“Handsome”))
    .findFirst();

//Scala approach
pets.find{ p=> p.getName == “Handsome” }

pets.filter { x => println(x.getName); true }.get(1) --- (1)

pets.toStream.filter { x => println(x.getName); true }.get(1) -- (2)

pets.view.filter { x => println(x.getName); true }.get(1) --- (3)