流的使用

筛选与切片

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

/**
 * 筛选与切片
 */
public class FilterDemo {
    public static void main(String[] args){
        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);

        numbers.stream()
                .filter(i->i%2==0) //使用谓词筛选
                .distinct() //去重
                .forEach(System.out::println);

        numbers.stream()
                .limit(3)//截断流
                .forEach(System.out::println);

        //跳过元素，limit(n)和skip(n)是互补的
        // skip(n)方法，返回一个扔掉了前n个元素的流,如果流中元素不足n个，则返回一 个空流
        numbers.stream()
                .skip(3)
                .forEach(System.out::println);


    }
}

映射

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


import static java.util.stream.Collectors.toList;

/**
 * 映射
 */
public class MapDemo {
    public static void main(String[] args){
        List<Apple> appleList = Arrays.asList(new Apple("red",12),new Apple("yellow",15),new Apple("green",10),new Apple("red",10));
        List<Integer> weigths = appleList.stream()
                .map(Apple::getWeight)
                .collect(toList());
//        System.out.println(weigths);
        List<Integer> colorNameLengths = appleList.stream()
                .map(Apple::getColor)//获取每个苹果的颜色
                .map(String::length)//然后获取苹果颜色内容的长度
                .collect(toList());
//        System.out.println(colorNameLengths);

        //流的扁平化
        String[] words = {"Hello","World"};
        List<String> collect = Arrays.stream(words)
                .map(w -> w.split(""))//将每个单词转换为由其字母构成的数组
                .flatMap(Arrays::stream)//将各个生成流扁平化为单个流
                .distinct()
                .collect(toList());
        System.out.println(collect);
    }
}

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

import static java.util.stream.Collectors.toList;

/**
 * 映射 练习
 */
public class MapDemo2 {
    public static void main(String[] args){
        //给定一个数字列表，如何返回一个由每个数的平方构成的列表呢?
        // 例如，给定[1, 2, 3, 4,5]，应该返回[1, 4, 9, 16, 25]
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> squares = numbers.stream().map(i -> i * i).collect(toList());
        System.out.println(squares);

        //给定列表[1, 2, 3]和列表[3, 4]，应 该返回[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]
        List<Integer> numbers1 = Arrays.asList(1, 2, 3);
        List<Integer> numbers2 = Arrays.asList(3, 4);

        //使用两个map来迭代这两个列表，并生成数对。但这样会返回一个Stream-
        //<Stream<Integer[]>>。你需要让生成的流扁平化，以得到一个Stream<Integer[]>
        List<int[]> pairs = numbers1.stream()
                .flatMap(i -> numbers2.stream()
                        .map(j -> new int[]{i, j}))
                .collect(toList());

    }
}

查找和匹配

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

/**
 * 查找和匹配
 * anyMatch、allMatch和noneMatch这三个操作都用到了我们所谓的短路
 * 不管表达式有多长，你只需找到一个表达式为false，就可以推断整个表达式 将返回false，所以用不着计算整个表达式。这就是短路
 */
public class MatchDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        //检查谓词是否至少匹配一个元素
        if (numbers.stream().anyMatch(i->i%2==0)){
            System.out.println("包含偶数");
        }
        //检查谓词是否匹配所有元素
        if (numbers.stream().allMatch(i->i%2==0)){
            System.out.println("全是偶数");
        }

        if (numbers.stream().noneMatch(i->i%2==0)){
            System.out.println("没有偶数");
        }

        //查找元素
        //Optional<T>类(java.util.Optional)是一个容器类，代表一个值存在或不存在
        // - isPresent()将在Optional包含值的时候返回true, 否则返回false。
        // - ifPresent(Consumer<T> block)会在值存在的时候执行给定的代码块。Consumer函数式接口;它让你传递一个接收T类型参数，并返回void的Lambda表达式。
        // - T get()会在值存在时返回值，否则抛出一个NoSuchElement异常。
        // - T orElse(T other)会在值存在时返回值，否则返回一个默认值。
        Optional<Integer> number = numbers.stream()
                .filter(i -> i % 2 == 0)
                .findAny();
        System.out.println(number.get());//T get()会在值存在时返回值

        numbers.stream()
                .filter(i -> i % 2 == 0)
                .findAny()
                .ifPresent(System.out::println);//如果包含一个 值就打印它，否则什么都不做

        //查找第一个元素
        System.out.println(numbers.stream()
                .filter(i -> i % 2 != 0)
                .findFirst()
                .orElse(-1));

    }
}

归约(折叠)

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

/**
* 归约(折叠)
* 将流中所有元素反复结合起来，得到一个值
*/
public class FoldDemo {
   public static void main(String[] args) {
       //元素求和
       List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
       int sum = 0;
       for (Integer x : numbers) {
           sum += x;
       }
       System.out.println(sum);

       //    T reduce(T identity, BinaryOperator<T> accumulator);
       // reduce接受两个参数:
       //  一个初始值，这里是0;
       //  一个BinaryOperator<T>来将两个元素结合起来产生一个新值，这里我们用的是 lambda (a, b) -> a + b
       // reduce操作是如何作用于一个流的:Lambda反复结合每个元素，直到流被归约成一个值
       int sum2 = numbers.stream().reduce(0, (a, b) -> a + b);
       int sum3 = numbers.stream().reduce(0, Integer::sum);
       System.out.println(sum3);
       // 无初始值
       // reduce操作无法返回其和，因为它没有初始值
       Optional<Integer> sumOp = numbers.stream().reduce(Integer::sum);
       System.out.println(sumOp.get());

       //最大值和最小值
       System.out.println(numbers.stream().reduce((x, y) -> x > y ? x : y).get());
       System.out.println(numbers.stream().reduce(Integer::max).get());

       //计算流中元素的个数
       System.out.println(numbers.stream().map(d -> 1)
               .reduce(Integer::sum).get());
       //内置count方法可用来计算流中元素的个数
       System.out.println(numbers.stream().count());
   }
}