Несколько примеров использования потокового API и лямбд в Java (работают начиная с 8 версии)

import java.io.File;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.Random;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class MainClass {
 
 private static void ln(){
 System.out.println("-------------------------------------------");
 }
 
 private static void disp(Object val){
 System.out.println(val.toString());
 }

 public static void main(String[] args) {
 
 ln();
 disp("вывод списка через лямбду");
 List strList = Arrays.asList("aaa", "fff", "cccc", "vvv", "bbb");
 strList.forEach(action -> System.out.println(action));
 
 ln();
 disp("вызов операций реализованные лямбдой");
 Tester tester = new Tester();
 MyAction action1 = tester.getAction();
 action1.doAction();
 
 MyCalculate calc1 = tester.getSummaOperation();
 System.out.println(calc1.operation(100, 200));
 
 calc1 = tester.getDiffOperation();
 System.out.println(calc1.operation(100, 200));
 
 calc1 = tester.getBiggest();
 System.out.println(calc1.operation(120, 150));
 
 calc1 = tester.getLowest();
 System.out.println(calc1.operation(99, 98));
 
 
 ln();
 disp("сортировка списка - компаратор через анонимный класс");
 List int_array = Arrays.asList(22, 56, 34, 5665, 34, 5757, 32);
 //Arrays.sort(int_array, (a, b) -> a > b);
 int_array.sort(new Comparator(){

 @Override
 public int compare(Integer o1, Integer o2) {
 return o2 - o1;
 }
 
 });
 int_array.forEach(value -> disp(value));
 
 ln();
 disp("сортировка списка через лямбду");
 int_array.sort((a, b) -> a - b);
 int_array.forEach(value -> disp(value));
 
 ln();
 disp("Файлы в директории");
 File file = new File("D:\\distrib");
 List fileList = Arrays.asList(file.listFiles());
 fileList.forEach(item -> disp(item.getAbsolutePath()));
 
 ln();
 disp("Только папки в директории");
 fileList.stream().filter(item -> item.isDirectory()).forEach(item -> disp(item.getAbsolutePath()));
 
 ln();
 disp("Только файлы в директории");
 fileList.stream().filter(Tester::isFolder).forEach(item -> disp(item.getAbsolutePath()));
 
 ln();
 disp("Только файлы zip и jar");
 Predicate isZipPredicate = Tester::isZipFile;
 Predicate isExePredicate = Tester::isExeFile;
 fileList.stream().filter(isZipPredicate.or(isExePredicate)).forEach(item -> disp(item.getName())); 
 
 ln();
 disp("Потестим потоковый API");
 List strings = Arrays.asList("begin", "", "sdfsf", "efwerwg", "abffsfsfsfcd","", "ajkl", "sdfsffsfsfsf", "", "the end", "ahsdjsd");
 strings.stream().filter(string -> !string.isEmpty()).map(item -> item.toUpperCase()).collect(Collectors.toList()).forEach(System.out::println);
 
 ln();
 disp("Фильтрация - выведем элементы списка начинающиеся на \"a\"");
 strings.stream().filter(predicate -> predicate.startsWith("a")).forEach(System.out::println);
 
 ln();
 disp("Заменим все пустые элементы на константы");
 strings.stream().map(item -> {if(item.isEmpty()) return "CONST"; return item;}).forEach(System.out::println);
 
 
 ln();
 disp("Заменим все пустые элементы на константы и ограничим 5 элементами");
 Consumer print = System.out::println;
 strings.stream().map(item -> {if(item.isEmpty()) return "CONST"; return item;}).limit(5).forEach(print);
 
 ln();
 disp("Отсортируем случайные числа");
 Random random = new Random();
 random.ints().limit(10).sorted().forEach(System.out::println);
 
 ln();
 disp("Заменим все пустые элементы на константы и отсортируем без учета регистра");
 strings.stream().map(item -> {if(item.isEmpty()) return "CONST"; return item;}).sorted((a, b) -> a.compareToIgnoreCase(b)).forEach(print);
 
 ln();
 disp("Выведем количество пустых элементов");
 disp(strings.parallelStream().filter(string -> string.isEmpty()).count());
 
 
 ln();
 disp("Используем peek");
 Stream.of("one", "two", "three", "sdfsdf","osdfsdfne", "sdfhrfyry", "three", "rtyrtyrty","oyuyuyune", "twyuyuyo", "thryuee", "fouyututr","onyuyuye", "tyutyuttyutyuwo", "thtyutyutree", "fouryuyuyu")
 .filter(e -> e.length() > 3)
 .peek(e -> System.out.println("Filtered value: " + e))
 .map(String::toUpperCase)
 .peek(e -> System.out.println("Mapped value: " + e))
 .collect(Collectors.toList());
 
 ln();
 disp("Используем reduce для умножения нечетных элементов списка");
 List int_arr = Arrays.asList(1, 2, 3, 4, 5);
 Optional res = int_arr.stream().filter(n -> n % 2 == 1).reduce((a, b) -> a*b);
 if(res.isPresent()) disp(res.get());
 
 ln();
 disp("Используем reduce для умножения нечетных элементов списка");
 res = int_arr.stream().reduce((a, b) -> {if(b % 2 == 1) return a * b; return a;});
 if(res.isPresent()) disp(res.get());
 
 ln();
 disp("Используем Сплитератор");
 Spliterator spl = Stream.of("one", "two", "three", "for", "fiveee").spliterator();
 spl.forEachRemaining(item -> disp(item));
 
 disp("еще раз Сплитератор");
 spl = Stream.of("one", "two", "three", "for", "fiveee").spliterator();
 while(spl.tryAdvance(item -> disp(item)));
 
 ln();
 disp("Используем map для преобразования потока строк в поток целых чисел, содержащих их длину");
 Stream strStream = Stream.of("one", "two", "three", "for", "fiveee");
 strStream.map(item -> new Integer(item.length())).forEach(item -> disp(item.toString()));
 
 ln();
 disp("Определяем вхождение элемента в потоке по критерию");
 List listValues = Arrays.asList("alex", "andrey", "aleksey", "adam", "angella", "alena", "arkadiiy");
 
 disp("любое вхождение");
 disp(listValues.stream().anyMatch(val -> val.startsWith("ang")));
 disp("все вхождения");
 disp(listValues.stream().allMatch(val -> val.startsWith("a")));
 disp("количество элементов в потоке");
 disp(listValues.stream().count());
 
 ln();
 disp("Попробуем ссылку на метод");
 listValues.stream().forEach(System.out::println);
 
 ln();
 disp("Попробуем параллельный поток на метод");
 listValues.parallelStream()
 .filter(e -> e.length() > 3)
 .peek(e -> System.out.println("Filtered value: " + e))
 .map(String::toUpperCase)
 .peek(e -> System.out.println("Mapped value: " + e))
 .collect(Collectors.toList());
 
 ln();
 disp("Конкатенация сведением");
 
 disp(listValues.stream().reduce((a, b) -> a + "_" + b).get());
 
 ln();
 disp(listValues.stream().reduce((a, b) -> a + "_" + b).orElse("Пустая строка"));
 ln();
 disp("сумма длинн слов в коллекции");
 disp(listValues.stream().map(str -> str.length()).reduce((a, b) -> a + b).orElse(0));
 
 disp("сумма длинн слов в коллекции с использовванием reduce (версия со значением идентичности) его можно расматривать как начальное значение");
 disp(listValues.stream().map(str -> str.length()).reduce(5, (a, b) -> a + b));
 
 disp(listValues.stream().map(str -> str.length()).reduce(5, (a, b) -> a + b));
 
 ln();
 disp("reduce с накоплением и объединением");
 List int_list = Arrays.asList(1.0, 4.0, 9.0, 1.0, 9.0, 1.0);
 disp(int_list.stream().peek(el -> System.out.println("el: " + el)).reduce(1.0 , (x, y) -> {disp("x = " + x); disp("y = " + y); return x * Math.sqrt(y);}, (a, b) -> {disp("a = " + a); disp("b = " + b); return a * b;}));
 ln();
 disp("reduce с накоплением и объединением");
 disp(int_list.stream().peek(el -> System.out.println("el: " + el)).reduce((x, y) -> x * Math.sqrt(y)).get());
 
 ln();
 final List prices = Arrays.asList(
 new BigDecimal("10"), new BigDecimal("30"), new BigDecimal("17"),
 new BigDecimal("20"), new BigDecimal("15"), new BigDecimal("18"),
 new BigDecimal("45"), new BigDecimal("12"));
 
 BigDecimal totalOfDiscountedPrices = BigDecimal.ZERO;
 for(BigDecimal price : prices) {
 if(price.compareTo(BigDecimal.valueOf(20)) > 0)
 totalOfDiscountedPrices =
 totalOfDiscountedPrices.add(price.multiply(BigDecimal.valueOf(0.9)));
 }
 System.out.println("Total of discounted prices: " + totalOfDiscountedPrices);
 
 totalOfDiscountedPrices =
 prices.stream()
 .filter(price -> price.compareTo(BigDecimal.valueOf(20)) > 0)
 .map(price -> price.multiply(BigDecimal.valueOf(0.9)))
 .reduce(BigDecimal.ZERO, BigDecimal::add);
 System.out.println("Total of discounted prices: " + totalOfDiscountedPrices);
 

 }

}