Какие создать поток данных в Stream API

# Как создать поток данных (Stream) в Stream API?

Stream API — это мощный инструмент в Java для работы с потоками данных в функциональном стиле. Есть множество способов создать Stream. Рассмотрю основные из них.

1. Stream из коллекции (Collection)

Это самый распространённый способ.

List<String> languages = Arrays.asList("Java", "Python", "C++");
Stream<String> stream = languages.stream();

Set<Integer> numbers = new HashSet<>(Arrays.asList(1, 2, 3));
Stream<Integer> numStream = numbers.stream();

// Практический пример
List<String> result = languages.stream()
    .filter(lang -> lang.length() > 4)
    .map(String::toUpperCase)
    .collect(Collectors.toList());
// Результат: [PYTHON]

2. Stream из массива

String[] array = {"Java", "Python", "C++"};
Stream<String> stream = Arrays.stream(array);

// Для примитивных типов
int[] numbers = {1, 2, 3, 4, 5};
IntStream intStream = Arrays.stream(numbers);
int sum = intStream.sum();  // 15

// Диапазон целых чисел
IntStream range = IntStream.range(1, 5);      // 1, 2, 3, 4
IntStream rangeClosed = IntStream.rangeClosed(1, 5);  // 1, 2, 3, 4, 5

// Использование
IntStream.range(1, 6)
    .forEach(System.out::println);  // Выведет 1, 2, 3, 4, 5

3. Stream.of()

Прямое создание Stream с перечисленными значениями.

Stream<String> stream = Stream.of("Java", "Python", "C++");

// Для примитивов
IntStream intStream = IntStream.of(1, 2, 3, 4, 5);
LongStream longStream = LongStream.of(10L, 20L, 30L);
DoubleStream doubleStream = DoubleStream.of(1.5, 2.5, 3.5);

// Практический пример
Stream.of("Apple", "Banana", "Cherry")
    .filter(s -> s.length() > 5)
    .forEach(System.out::println);  // Выведет: Banana, Cherry

4. Stream из диапазона (Range)

// Для целых чисел
IntStream.range(0, 10)          // 0-9
    .forEach(System.out::println);

IntStream.rangeClosed(0, 10)    // 0-10
    .forEach(System.out::println);

// Для long
LongStream.range(0, 1000000);
LongStream.rangeClosed(0, 1000000);

// Практический пример: таблица умножения
IntStream.rangeClosed(1, 5)
    .forEach(i -> {
        IntStream.rangeClosed(1, 5)
            .forEach(j -> System.out.print(i * j + " "));
        System.out.println();
    });

5. Stream.iterate()

Создание потока с помощью итератора — для генерации бесконечной последовательности.

// Бесконечный поток
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);

// Ограничиваем количество элементов
Stream<Integer> limitedStream = Stream.iterate(0, n -> n + 1)
    .limit(10);
limitedStream.forEach(System.out::println);  // 0, 1, 2, ..., 9

// С условием прерывания (Java 9+)
Stream<Integer> stream = Stream.iterate(0, n -> n < 10, n -> n + 1);
stream.forEach(System.out::println);  // 0, 1, 2, ..., 9

// Практический пример: Последовательность Фибоначчи
Stream.iterate(new long[]{0, 1}, n -> new long[]{n[1], n[0] + n[1]})
    .limit(10)
    .forEach(n -> System.out.println(n[0]));

6. Stream.generate()

Создание потока с помощью функции-поставщика (Supplier).

import java.util.stream.Stream;

// Генерация случайных чисел
Stream<Integer> randomStream = Stream.generate(
    () -> new Random().nextInt(100)
).limit(10);

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

// Генерация одного и того же значения
Stream<String> repeating = Stream.generate(() -> "Java")
    .limit(5);
repeating.forEach(System.out::println);  // Java 5 раз

// Практический пример: UUID генератор
import java.util.UUID;

Stream<String> uuids = Stream.generate(() -> UUID.randomUUID().toString())
    .limit(5);

7. Stream из String

String text = "Hello World";

// Поток символов
IntStream chars = text.chars();  // Коды ASCII
chars.forEach(c -> System.out.println((char) c));

// Поток кодов Unicode
IntStream codePoints = text.codePoints();
codePoints.forEach(System.out::println);

// Практический пример: подсчёт букв
String word = "programming";
long uniqueLetters = word.chars()
    .distinct()
    .count();  // 8

8. Stream из файла (NIO)

import java.nio.file.Files;
import java.nio.file.Paths;

// Читать строки из файла
try (Stream<String> lines = Files.lines(Paths.get("data.txt"))) {
    lines.filter(line -> !line.isEmpty())
        .map(String::trim)
        .forEach(System.out::println);
}

// Подсчитать количество строк
long lineCount = Files.lines(Paths.get("data.txt")).count();

// Прочитать все содержимое в List
List<String> allLines = Files.lines(Paths.get("data.txt"))
    .collect(Collectors.toList());

9. Stream из Map

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 85);
scores.put("Bob", 90);
scores.put("Charlie", 78);

// Поток из ключей
scores.keySet().stream()
    .forEach(System.out::println);

// Поток из значений
scores.values().stream()
    .filter(score -> score > 80)
    .forEach(System.out::println);  // 85, 90

// Поток из Entry (пара ключ-значение)
scores.entrySet().stream()
    .filter(entry -> entry.getValue() > 80)
    .forEach(entry -> System.out.println(
        entry.getKey() + ": " + entry.getValue()
    ));

10. Stream из Optional

Optional<String> optional = Optional.of("Java");

// Конвертировать Optional в Stream
Stream<String> stream = optional.stream();
stream.forEach(System.out::println);  // Java

// Практический пример
List<String> strings = Arrays.asList("Java", null, "Python");
strings.stream()
    .flatMap(s -> Optional.ofNullable(s).stream())
    .forEach(System.out::println);  // Java, Python (null пропущен)

11. Stream.concat() — объединение потоков

Stream<String> stream1 = Stream.of("Java", "Python");
Stream<String> stream2 = Stream.of("C++", "Go");

Stream<String> combined = Stream.concat(stream1, stream2);
combined.forEach(System.out::println);
// Выведет: Java, Python, C++, Go

// Практический пример: объединить несколько источников
List<String> languages = Arrays.asList("Java", "Python");
Set<String> frameworks = new HashSet<>(Arrays.asList("Spring", "Django"));

Stream.concat(
    languages.stream(),
    frameworks.stream()
).forEach(System.out::println);

12. FlatMap для преобразования потока потоков

List<List<String>> lists = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d"),
    Arrays.asList("e", "f")
);

// Без flatMap получим Stream<List<String>>
// С flatMap получим Stream<String>
lists.stream()
    .flatMap(list -> list.stream())
    .forEach(System.out::println);
// Выведет: a, b, c, d, e, f

// Практический пример: слова из предложений
List<String> sentences = Arrays.asList(
    "Hello World",
    "Java Streams",
    "Are Powerful"
);

sentences.stream()
    .flatMap(s -> Stream.of(s.split(" ")))
    .forEach(System.out::println);
// Выведет: Hello, World, Java, Streams, Are, Powerful

Сравнение способов создания

Ленивое вычисление

Важно понимать, что Stream API — это ленивое (lazy). Операции не выполняются до тех пор, пока не будет вызвана терминальная операция (collect, forEach, count и т.д.).

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5)
    .filter(n -> {
        System.out.println("Фильтрую: " + n);
        return n > 2;
    })
    .map(n -> {
        System.out.println("Преобразую: " + n);
        return n * 2;
    });

System.out.println("Stream создан");
// До этого момента nothing печатается!

stream.forEach(System.out::println);
// Теперь печатается всё

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