Java Stream API: как преобразовать данные декларативным стилем

List<String> longNames = new ArrayList<>();
for (String name : names) {
if (name.length() > 5) {
longNames.add(name.toUpperCase());
}
}
Collections.sort(longNames);

List<String> longNames = names.stream()
.filter(name -> name.length() > 5)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());

// Из коллекции
List<String> list = Arrays.asList("Java", "Stream", "API");
Stream<String> streamFromCollection = list.stream();

// Из массива
String[] array = {"Java", "Stream", "API"};
Stream<String> streamFromArray = Arrays.stream(array);

// Из строки (поток символов)
IntStream streamFromString = "hello".chars();

// Создание потока с помощью Stream.of()
Stream<String> streamFromValues = Stream.of("Java", "Stream", "API");

// Создание бесконечного потока с генератором
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2);

// Создание потока случайных чисел
Stream<Double> randomStream = Stream.generate(Math::random);

// Из файла (требует обработки исключений)
Stream<String> streamFromFile = Files.lines(Paths.get("file.txt"));

// Фильтрация чисел больше 10
List<Integer> numbers = Arrays.asList(1, 15, 20, 3, 8, 12);
List<Integer> filtered = numbers.stream()
.filter(n -> n > 10)
.collect(Collectors.toList()); // [15, 20, 12]

// Фильтрация непустых строк
List<String> words = Arrays.asList("hello", "", "world", "", "java");
List<String> nonEmpty = words.stream()
.filter(s -> !s.isEmpty())
.collect(Collectors.toList()); // [hello, world, java]

// Преобразование строк в их длины
List<String> words = Arrays.asList("Java", "Stream", "API");
List<Integer> lengths = words.stream()
.map(String::length)
.collect(Collectors.toList()); // [4, 6, 3]

// Преобразование чисел в их квадраты
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> squares = numbers.stream()
.map(n -> n * n)
.collect(Collectors.toList()); // [1, 4, 9, 16, 25]

// Преобразование объектов
List<User> users = Arrays.asList(
new User("John", "Doe", 30),
new User("Jane", "Smith", 25)
);
List<String> fullNames = users.stream()
.map(user -> user.getFirstName() + " " + user.getLastName())
.collect(Collectors.toList()); // [John Doe, Jane Smith]

// Работа с вложенными списками
List<List<Integer>> nestedLists = Arrays.asList(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5),
Arrays.asList(6, 7, 8)
);

List<Integer> flattened = nestedLists.stream()
.flatMap(Collection::stream)
.collect(Collectors.toList()); // [1, 2, 3, 4, 5, 6, 7, 8]

// Разбиение строк на слова
List<String> sentences = Arrays.asList(
"Hello world",
"Java Stream API"
);

List<String> words = sentences.stream()
.flatMap(sentence -> Arrays.stream(sentence.split("\\s+")))
.collect(Collectors.toList()); // [Hello, world, Java, Stream, API]

// Сортировка чисел по возрастанию (естественный порядок)
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 3);
List<Integer> sorted = numbers.stream()
.sorted()
.collect(Collectors.toList()); // [1, 2, 3, 5, 8]

// Сортировка строк по длине
List<String> words = Arrays.asList("Java", "Stream", "API", "Programming");
List<String> sortedByLength = words.stream()
.sorted(Comparator.comparing(String::length))
.collect(Collectors.toList()); // [API, Java, Stream, Programming]

// Сортировка объектов по нескольким полям
List<User> users = Arrays.asList(
new User("John", "Doe", 30),
new User("Jane", "Smith", 25),
new User("Jane", "Doe", 28)
);

List<User> sortedUsers = users.stream()
.sorted(
Comparator.comparing(User::getLastName)
.thenComparing(User::getFirstName)
.thenComparing(User::getAge)
)
.collect(Collectors.toList());

// Сбор в список
List<String> collected = stream.collect(Collectors.toList());

// Сбор в множество
Set<String> uniqueElements = stream.collect(Collectors.toSet());

// Сбор в карту (ключ -> значение)
Map<Integer, String> idToName = persons.stream()
.collect(Collectors.toMap(
Person::getId, // функция получения ключа
Person::getName // функция получения значения
));

// Сбор в строку
String joined = stream.collect(Collectors.joining(", "));

// Подсчёт элементов
Long count = stream.collect(Collectors.counting());

// Статистика числовых значений
IntSummaryStatistics stats = numbers.stream()
.collect(Collectors.summarizingInt(Integer::intValue));
System.out.println("Average: " + stats.getAverage());
System.out.println("Sum: " + stats.getSum());

// Сумма чисел
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b); // или .reduce(0, Integer::sum);
// результат: 15

// Поиск максимального элемента
Optional<Integer> max = numbers.stream()
.reduce(Integer::max);
// результат: Optional[5]

// Конкатенация строк
List<String> words = Arrays.asList("Java", "Stream", "API");
String concatenated = words.stream()
.reduce("", (a, b) -> a + b); // или .reduce("", String::concat);
// результат: "JavaStreamAPI"

// Более сложный пример: подсчёт суммы длин строк
int totalLength = words.stream()
.reduce(0, 
(sum, word) -> sum + word.length(),
Integer::sum);
// результат: 13

// Простая печать элементов
Stream.of("Java", "Stream", "API")
.forEach(System.out::println);

// Выполнение действия над элементами
List<User> users = getUserList();
users.stream()
.filter(user -> user.getAge() > 18)
.forEach(user -> user.sendNotification("Welcome!"));

// Использование forEachOrdered для гарантированного сохранения порядка
// (важно для параллельных потоков)
stream.parallel()
.forEachOrdered(System.out::println);

// Поиск первого элемента, удовлетворяющего условию
Optional<String> firstLongName = names.stream()
.filter(name -> name.length() > 6)
.findFirst();

// Проверка, есть ли хоть один элемент, удовлетворяющий условию
boolean hasAdult = persons.stream()
.anyMatch(person -> person.getAge() >= 18);

// Проверка, все ли элементы удовлетворяют условию
boolean allPositive = numbers.stream()
.allMatch(n -> n > 0);

// Поиск минимального элемента
Optional<Person> youngest = persons.stream()
.min(Comparator.comparing(Person::getAge));

List<Person> people = Arrays.asList(
new Person("John", 25, "USA"),
new Person("Alice", 30, "UK"),
new Person("Bob", 25, "USA"),
new Person("Charlie", 35, "UK")
);

// Группировка по возрасту
Map<Integer, List<Person>> byAge = people.stream()
.collect(Collectors.groupingBy(Person::getAge));
// Результат: {25=[John, Bob], 30=[Alice], 35=[Charlie]}

// Группировка по стране
Map<String, List<Person>> byCountry = people.stream()
.collect(Collectors.groupingBy(Person::getCountry));
// Результат: {USA=[John, Bob], UK=[Alice, Charlie]}

// Группировка по стране, затем по возрасту
Map<String, Map<Integer, List<Person>>> byCountryAndAge = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.groupingBy(Person::getAge)
));
// Результат: {USA={25=[John, Bob]}, UK={30=[Alice], 35=[Charlie]}}

// Количество людей в каждой стране
Map<String, Long> countByCountry = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.counting()
));
// Результат: {USA=2, UK=2}

// Средний возраст людей в каждой стране
Map<String, Double> averageAgeByCountry = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.averagingInt(Person::getAge)
));
// Результат: {USA=25.0, UK=32.5}

// Поиск человека с максимальным возрастом в каждой стране
Map<String, Optional<Person>> oldestByCountry = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.maxBy(Comparator.comparing(Person::getAge))
));

// Сбор имен людей из каждой страны в строку
Map<String, String> namesByCountry = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.mapping(
Person::getName,
Collectors.joining(", ")
)
));
// Результат: {USA="John, Bob", UK="Alice, Charlie"}

// Разделение людей на две группы: старше 30 лет и остальные
Map<Boolean, List<Person>> partitionedByAge = people.stream()
.collect(Collectors.partitioningBy(p -> p.getAge() > 30));
// Результат: {false=[John, Alice, Bob], true=[Charlie]}

// Нахождение человека с минимальным возрастом в каждой стране
Map<String, Person> youngestByCountry = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.collectingAndThen(
Collectors.minBy(Comparator.comparing(Person::getAge)),
Optional::get // Предполагаем, что группы не пусты
)
));

// Сбор статистики по возрасту в каждой стране
Map<String, IntSummaryStatistics> ageStatsByCountry = people.stream()
.collect(Collectors.groupingBy(
Person::getCountry,
Collectors.summarizingInt(Person::getAge)
));

// Вывод статистики
ageStatsByCountry.forEach((country, stats) -> {
System.out.println(country + " Statistics:");
System.out.println(" Count: " + stats.getCount());
System.out.println(" Sum: " + stats.getSum());
System.out.println(" Min: " + stats.getMin());
System.out.println(" Average: " + stats.getAverage());
System.out.println(" Max: " + stats.getMax());
});

// Создание кастомного коллектора для подсчета частоты букв в строках
Collector<String, Map<Character, Integer>, Map<Character, Integer>> frequencyCollector = 
Collector.of(
HashMap::new, // supplier – создает начальный результат
(map, str) -> { // accumulator – обрабатывает каждый элемент
for (char c : str.toCharArray()) {
map.merge(c, 1, Integer::sum);
}
},
(map1, map2) -> { // combiner – объединяет результаты (для parallel stream)
Map<Character, Integer> result = new HashMap<>(map1);
map2.forEach((k, v) -> result.merge(k, v, Integer::sum));
return result;
}
);

List<String> words = Arrays.asList("hello", "world");
Map<Character, Integer> letterFrequency = words.stream().collect(frequencyCollector);
// Результат: {d=1, e=1, h=1, l=3, o=2, r=1, w=1}