Можно ли массив превратить в Stream?

Можно ли превратить массив в Stream?

Да, абсолютно да! Это один из основных способов использования Stream API в Java. Существует несколько методов для преобразования массива в поток данных.

Основные способы конвертации массива в Stream

1. Arrays.stream() для примитивных типов

Для массивов примитивных типов (int, double, long, boolean):

import java.util.Arrays;

public class ArrayToStreamExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // Преобразуем в IntStream
        Arrays.stream(numbers)
            .filter(n -> n > 2)
            .forEach(System.out::println);  // 3, 4, 5
    }
}

Доступные потоки для примитивов:

int[] intArray = {1, 2, 3};
IntStream intStream = Arrays.stream(intArray);

long[] longArray = {1L, 2L, 3L};
LongStream longStream = Arrays.stream(longArray);

double[] doubleArray = {1.0, 2.0, 3.0};
DoubleStream doubleStream = Arrays.stream(doubleArray);

2. Arrays.stream() для объектов

Для массивов объектов (String, Integer, Custom classes):

import java.util.Arrays;

public class ObjectArrayToStream {
    public static void main(String[] args) {
        String[] fruits = {"яблоко", "банан", "апельсин", "груша"};
        
        // Преобразуем в Stream<String>
        Arrays.stream(fruits)
            .filter(f -> f.length() > 5)
            .map(String::toUpperCase)
            .forEach(System.out::println);  // АПЕЛЬСИН
    }
}

3. Stream.of() для объектов

Это альтернатива для массивов объектов:

import java.util.stream.Stream;

public class StreamOfExample {
    public static void main(String[] args) {
        Integer[] numbers = {10, 20, 30, 40, 50};
        
        // Способ 1: Arrays.stream()
        Arrays.stream(numbers)
            .forEach(System.out::println);
        
        // Способ 2: Stream.of()
        Stream.of(numbers)
            .forEach(System.out::println);
        
        // Способ 3: без массива, прямая вариадическая передача
        Stream.of(100, 200, 300, 400, 500)
            .forEach(System.out::println);
    }
}

Разница между Arrays.stream() и Stream.of()

Integer[] array = {1, 2, 3};

// Arrays.stream() — на самом деле работает со Stream<Integer>
Arrays.stream(array).forEach(System.out::println);

// Stream.of() — варианты
Stream.of(array).forEach(System.out::println);        // Весь массив как элемент?
Stream.of(1, 2, 3).forEach(System.out::println);      // Правильный способ

Важный момент: для примитивных массивов:

int[] primitives = {1, 2, 3};

// ✅ Правильно
Arrays.stream(primitives).forEach(System.out::println);

// ❌ Неправильно — Stream.of() не работает с примитивными массивами
// Stream.of(primitives)  // Это создаст Stream с одним элементом [I@...

Практические примеры

1. Фильтрация и трансформация

import java.util.Arrays;

public class FilterAndMap {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        
        int sum = Arrays.stream(numbers)
            .filter(n -> n % 2 == 0)      // Чётные числа
            .map(n -> n * n)              // Возводим в квадрат
            .sum();                        // Суммируем
        
        System.out.println(sum);  // 4 + 16 + 36 + 64 + 100 = 220
    }
}

2. Поиск максимума/минимума

import java.util.Arrays;
import java.util.OptionalInt;

public class MinMaxExample {
    public static void main(String[] args) {
        int[] scores = {85, 92, 78, 95, 88, 91};
        
        OptionalInt max = Arrays.stream(scores).max();
        OptionalInt min = Arrays.stream(scores).min();
        
        max.ifPresent(m -> System.out.println("Макс: " + m));  // Макс: 95
        min.ifPresent(m -> System.out.println("Мин: " + m));   // Мин: 78
    }
}

3. Группировка и статистика

import java.util.Arrays;
import java.util.IntSummaryStatistics;

public class StatsExample {
    public static void main(String[] args) {
        int[] data = {5, 10, 15, 20, 25};
        
        IntSummaryStatistics stats = Arrays.stream(data)
            .summaryStatistics();
        
        System.out.println("Сумма: " + stats.getSum());         // 75
        System.out.println("Среднее: " + stats.getAverage());   // 15.0
        System.out.println("Макс: " + stats.getMax());          // 25
        System.out.println("Мин: " + stats.getMin());           // 5
        System.out.println("Количество: " + stats.getCount());  // 5
    }
}

4. Работа со строками (объекты)

import java.util.Arrays;

public class StringArrayExample {
    public static void main(String[] args) {
        String[] cities = {"москва", "санкт-петербург", "казань", "новосибирск"};
        
        // Фильтруем и преобразуем
        Arrays.stream(cities)
            .filter(city -> city.length() >= 5)
            .map(String::toUpperCase)
            .sorted()
            .forEach(System.out::println);
        // КАЗАНЬ
        // МОСКВА
        // НОВОСИБИРСК
        // САНКТ-ПЕТЕРБУРГ
    }
}

Производительность и особенности

1. Ленивые операции (lazy evaluation)

import java.util.Arrays;

public class LazyEvaluation {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // Операция НЕ выполняется до вызова терминальной операции
        var stream = Arrays.stream(numbers)
            .peek(n -> System.out.println("Проверяю: " + n))
            .filter(n -> n > 2);
        
        // Еще ничего не напечатано!
        
        // Только здесь начинают выполняться операции
        stream.forEach(System.out::println);
        // Выведет: Проверяю: 1, Проверяю: 2, Проверяю: 3, 3, ...
    }
}

2. Стоимость преобразования

Для примитивных массивов преобразование дешёво (нет boxing):

int[] arr = {1, 2, 3};  // Примитивный массив

// ✅ Эффективно — никаких обёрток
Arrays.stream(arr).sum();

// ❌ Неэффективно — создаёт Integer объекты (boxing)
Integer[] arr2 = {1, 2, 3};
Arrays.stream(arr2).mapToInt(Integer::intValue).sum();

Сравнение разных подходов

import java.util.Arrays;
import java.util.List;

public class ComparisonExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        // Подход 1: Classic for loop
        for (int n : numbers) {
            if (n > 2) System.out.println(n);
        }
        
        // Подход 2: Stream API
        Arrays.stream(numbers)
            .filter(n -> n > 2)
            .forEach(System.out::println);
        
        // Подход 3: Через List (менее эффективно)
        List.of(numbers).stream()
            .filter(n -> n > 2)
            .forEach(System.out::println);
    }
}

Вложенные массивы

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

import java.util.Arrays;

public class NestedArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        
        // Преобразуем в единый поток всех элементов
        Arrays.stream(matrix)
            .flatMap(Arrays::stream)  // flatMap для развёртывания
            .filter(n -> n > 4)
            .forEach(System.out::println);
        // 5, 6, 7, 8, 9
    }
}

Таблица методов преобразования

Best Practices

✅ Правильно:

• Используйте Arrays.stream() для массивов
• Используйте IntStream/LongStream/DoubleStream для примитивов
• Применяйте filter() и map() для преобразований
• Используйте collect() для конечного результата

❌ Неправильно:

• Не используйте Stream для простых циклов (неэффективно)
• Не конвертируйте примитивные массивы в List для Stream
• Не забывайте о терминальных операциях (forEach, collect и т.д.)

Вывод

Да, массив легко превратить в Stream несколькими способами:

1. Arrays.stream() — основной способ (рекомендуется)
2. Stream.of() — для объектов с вариадическими аргументами
3. IntStream/LongStream/DoubleStream — специализированные для примитивов

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