Java потоки | www.nookery.ru

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

Мы используем агрегатные функции в SQL чаще. Например, мы можем суммировать все цифры продажи за месяц или год. Мы также можем получать заданные значение максимального диапазона.

Агрегатная операция работает над списком пункта и приводит к одному значению.

Результатом совокупных операций на поток может быть элементарное значение, объект, или пустота для потока. Как например в SQL мы можем вычислить сумму всех целых чисел в потоке целых чисел.

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

Java Collections сосредоточены на том, чтобы хранить элементы данных для эффективного доступа.

Java потоки сосредоточены на совокупных операций на элементах данных из источника данных.

Потоки (Streams)

Java Streams имеют свои особенности.

Java Streams не имеют места хранения.

Коллекция представляет собой структуру данных в оперативной памяти, которая хранит все его элементы.

Поток не имеет памяти. Поток тянет элементы из источника данных по требованию и передает их в трубопровод операций по переработке.

Для коллекции мы говорим о хранении или как элементы данных хранятся, как получить доступ к элементам данных.

Потока сконцентрировано внимание на операциях, например, как подводить поток.

Бесконечные Потоки (Streams)

Коллекция не может представлять собой группу бесконечных элементов в то время как поток может.

Поток может вытянуть его элементы из источника данных. Источник данных может быть коллекция, функция, которая генерирует данные, канал ввода / вывода и т.д.

Поток может извлекать данные из из функции, которая генерирует бесконечное число элементов.

Поток не может быть повторно использован после вызова терминала операции.

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

Поток может бросить legalStateException в случае многократного использования.

Внешняя итерация

При работе с Java Collections мы используем внешнюю итерацию.

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

Следующий код вычисляет сумму квадратов всех нечетных чисел в списке.

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

После этого она вычисляет квадрат и хранит сумму квадрата в переменной.

//nookery.ru
import java.util.Arrays;
import java.util.List;

public class Test {
  public static void main(String[] args) {
    List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);
    int result= 0;
    for (int n : num) {
      if (n % 2 == 1) {
        int square = n * n;
        result = result + square;
      }
    }
    System.out.println(result);
  }
}

//nookery.ru

import java.util.Arrays;

import java.util.List;

public class Test {

public static void main(String[] args) {

List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);

int result= 0;

for (int n : num) {

if (n % 2 == 1) {

int square = n * n;

result = result + square;

}

System.out.println(result);

}

Результатом работы программы будет: 35

Внутренняя итерация

Мы можем переписать код, указанный выше, используя поток. Он делает то же самое.

//nookery.ru
import java.util.Arrays;
import java.util.List;

public class Test {
  public static void main(String[] args) {
    List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);
    int result = num.stream()
        .filter(n -> n % 2  == 1)
        .map(n  -> n * n)
        .reduce(0, Integer::sum);

    System.out.println(result);
  }
}

//nookery.ru

import java.util.Arrays;

import java.util.List;

public class Test {

public static void main(String[] args) {

List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);

int result = num.stream()

.filter(n -> n % 2 == 1)

.map(n -> n * n)

.reduce(0, Integer::sum);

System.out.println(result);

}

В коде выше мы не использовали оператор цикла для итерации по списку. Мы сделали петлю внутри потока.

Для расчета нечетного мы использовали лямбда-выражения. Сначала мы сделали фильтр, затем карту, затем уменьшили.

Результатом работы программы будет: 35

Последовательный код.

Внешняя итерация обычно означает последовательный код. Последовательный код может выполняться только одним потоком.

Струйные предназначены для обработки элементов параллельно.

Следующий код вычисляет сумму квадратов нечетных чисел в списке параллельно.

//nookery.ru
import java.util.Arrays;
import java.util.List;

public class Test {
  public static void main(String[] args) {
    List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);
    int result = num.parallelStream()
        .filter(n -> n % 2  == 1)
        .map(n  -> n * n)
        .reduce(0, Integer::sum);

    System.out.println(result);
  }
}

//nookery.ru

import java.util.Arrays;

import java.util.List;

public class Test {

public static void main(String[] args) {

List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);

int result = num.parallelStream()

.filter(n -> n % 2 == 1)

.map(n -> n * n)

.reduce(0, Integer::sum);

System.out.println(result);

}

То , что мы сделали , это просто заменили stream() на parallelStream()

Параллельные вычисления осуществить легко при использовании внутренней итерации, представленную потоком.

Результатом работы программы будет: 35

Java потоки и Java API поток.

Интерфейсы потоков и классы потоков, находятся в пакете java.util.stream.

AutoCloseable интерфейс из пакета java.lang.

Все интерфейсы потока наследуют от интерфейса BaseStream, который наследуется от интерфейса AutoCloseable.

Если потоки используют коллекции в качестве источника данных, то коллекции не должны быть закрыты.

Если поток основан на закрывающимся источнике данных, таких как канал ввода / вывода файла, мы можем создать поток с использованием примерочных с ресурсами-заявлений, чтобы иметь возможность его автоматически закрыть.

Основной поток

Интерфейс BaseStream определяет все методы, общие для всех типов потоков.

Iterator <T>iterator()
терминал операция
возвращает итератор для потока.
sequential()
промежуточная операция
возвращает последовательный поток. Если поток уже последовательный, он возвращает себя. Он преобразует параллельный поток в последовательном потоке.
parallel()
промежуточная операция
возвращает параллельный поток. Если поток уже параллельный, он возвращает себя. Он преобразует параллельный поток в последовательный поток.
boolean isParallel()
возвращает истину , если поток параллельный, ложь в противном случае. При вызове этого метода после вызова терминального метода операции потока может привести к непредсказуемым результатам.
unordered()
промежуточная операция
возвращает неупорядоченную версию потока. Если поток уже неупорядоченный, он возвращает себя.

Поток Stream

Stream<T>interface представляет собой поток типа элемента Т.

Поток <Dog> представляет собой поток Dogobjects.

Интерфейс потока <T> содержит методы, такие как filter(), map(), reduce(), collect(), max(), min(), и.т.д.

При работе с примитивными типами мы можем использовать три специализированных интерфейса потока так называемые IntStream , LongStream и DoubleStream .

Эти интерфейсы предоставляют методы для борьбы с примитивными значениями.

Для других примитивных типов, таких как float, short, byte, мы все еще можем использовать три специализированные интерфейсы потока.

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

Рассмотрим поэтапно написания кода программы.

Создание потока

Метод stream() в интерфейсе Collection возвращает последовательный поток. Таким образом Коллекция выступает в качестве источника данных.

Следующий код создает List <Integer> и получает поток <Integer> из списка:

List<Integer>  numList = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> numStream  = numList.stream();

1 2	List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5); Stream<Integer> numStream = numList.stream();

Фильтр потока (Filter stream)

Stream<T>filter() использует Predicate <T> , чтобы сохранить элементы , если указанна Predicate возвращает истину для этого элемента.

Следующий оператор получает поток только нечетных чисел:

Stream <Integer> NStream = numStream.filter (п -> п% 2 == 1);

1	Stream <Integer> NStream = numStream.filter (п -> п% 2 == 1);

Карта потока (Map Stream)

Stream<T>map() использует функцию для отображения каждого элемента в потоке и создать новый поток.

Следующий оператор отображает поток, в котором происходит вычисление квадрата.

Stream<Integer> NStream = stream.map(n -> n * n);

1	Stream<Integer> NStream = stream.map(n -> n * n);

Уменьшить поток (Reduce Stream)

reduce(T indenity, BinaryOperator<T>accumulator)

1	reduce(T indenity, BinaryOperator<T>accumulator)

уменьшает поток к единственному значению.

Он принимает начальное значение и accumulator, которым является

BinaryOperator<T>

1	BinaryOperator<T>

в качестве аргумента.

reduce(T identity, BinaryOperator <T>accumulator)

1	reduce(T identity, BinaryOperator <T>accumulator)

выполняет сокращение на элементах этого потока, используя прилагаемое начальное значение и ассоциативную функцию накопления, и возвращаемое значение уменьшается.

Посмотрим код ниже:

T result = identity;
for (T element : this stream)
  result = accumulator.apply(result, element)
return result;

T result = identity;

for (T element : this stream)

result = accumulator.apply(result, element)

return result;

Следующий код сумирует все целые числа в потоке.

int sum = aStream.reduce (0, (n1, n2) -> n1 + n2);

1	int sum = aStream.reduce (0, (n1, n2) -> n1 + n2);

Integer.sum () метод выполняет сумму двух целых чисел.

Мы можем переписать код, используя эталонный метод.

int sum = aStream.reduce (0, Integer :: sum);

1	int sum = aStream.reduce (0, Integer :: sum);

Объединение операций в целое.

Следующий код объединяет каждый шаг вместе.

//nookery.ru
import java.util.Arrays;
import java.util.List;
public class Test {
  public static void main(String[] args) {
    List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);
    int result = num.stream()
        .filter(n -> n % 2  == 1)
        .map(n  -> n * n)
        .reduce(0, Integer::sum);

    System.out.println(result);
  }
}

//nookery.ru

import java.util.Arrays;

import java.util.List;

public class Test {

public static void main(String[] args) {

List<Integer> num = Arrays.asList(1, 2, 3, 4, 5);

int result = num.stream()

.filter(n -> n % 2 == 1)

.map(n -> n * n)

.reduce(0, Integer::sum);

System.out.println(result);

}

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

Потоки (Streams)

Бесконечные Потоки (Streams)

Внешняя итерация

Внутренняя итерация

Последовательный код.

Java потоки и Java API поток.

Поток Stream

Создание потока

Объединение операций в целое.

Добавить комментарий Отменить ответ