集合链式编程

1. 数据源的获取

ArrayList<Integer> list=new ArrayList<>();
Collections.addAll(list,0,1,2,3,4,5,6,7,8,9,10);

//1.以集合作为数据源，读取数据到流中
//1.1数据源的获取
Stream<Integer> stream = list.stream();
//1.2这也是一种获取数据源的方法，但是这是一个并行流
Stream<Integer> parallelStream = list.parallelStream();

//2.以数据作为数据源，读取到数据流中
Integer[] array={0,1,2,3,4,5,6,7,8,9,10};
Stream<Integer> stream1 = Arrays.stream(array);

2. 最终操作

.//将流转换成集合
private static void finalOperatorCollect() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();

    // 2. 将数据流中的数据，收集起来，做成一个新的集合
    // 2.1. 将流中的数据，收集起来，存入一个List集合返回
    // List list = stream.collect(Collectors.toList());
    // 2.2. 将流中的数据，收集起来，存入一个Set集合返回
    // Set list = stream.collect(Collectors.toSet());
    // 2.3. 将流中的数据，收集起来，存入一个Map集合返回
    //      方法参数，是两个Function接口类型的
    //      第一个Function是流中的元素到键的映射
    //      第二个Function是流中的元素到值的映射
    // Map map = stream.collect(Collectors.toMap(k -> k + "!", v -> v));
    // System.out.println(map);
}

//提供了一个计算规则，将流中的数据依次带入到这个计算规则中进行计算，得到一个最终的结果
private static void finalOperatorReduce() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. reduce: 提供了一个计算规则，将流中的数据依次带入到这个计算规则中进行计算，得到一个最终的结果
    // Optional
    Integer sum = stream.reduce((n1, n2) -> n1 + n2).get();
    System.out.println(sum);
}

//获取流中的数量
private static void finalOperatorCount() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. 获取流中的数据数量
    long count = stream.count();
    System.out.println(count);
}

//遍历流中的数据
private static void finalOperatorForEach() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. 将流中的每一个元素，依次带入到参数 Comsumer 的方法中
    stream.forEach(System.out::println);
}

//流中的最大值
private static void finalOperatorMax() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. max: 获取一个流中最大的元素
    //    Comparator: 定制一个大小比较的规则
    Integer max = stream.max(Integer::compareTo).get();
    System.out.println(max);
}

//流中的最小值
private static void finalOperatorMin() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. min: 获取一个流中最小的元素
    //    Comparator: 定制一个大小比较的规则
    Integer max = stream.min(Integer::compareTo).get();
    System.out.println(max);
}

//判断流中是否存在满足条件的数据
private static void finalOperatorMatching() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. Matching: 用来做匹配的，检查流中的数据，是否有满足指定条件的数据，返回值是 boolean
    //    allMatch: 当流中的所有的元素，都满足指定的条件，才会返回true；有任意的数据不满足条件，都会返回false
    //    anyMatch: 只要流中的元素，有满足指定条件的，就返回true；只有当流中的元素都不满足条件，才会返回false
    //    noneMatch: 只有当流中的所有元素都不满足指定的条件，才会返回true；只要有任意的数据满足条件，都会返回false
    boolean ret1 = stream.allMatch(n -> n > 0);
    System.out.println(ret1);
    // boolean ret2 = stream.anyMatch(n -> n > 50);
    // System.out.println(ret2);
    // boolean ret3 = stream.noneMatch(n -> n > 500);
    // System.out.println(ret3);
}

//从流中得到一个满足料件的数据
private static void finalOperatorFind() {
    // 1. 获取数据源
    Stream<Integer> stream = getDataSource().stream();
    // 2. find: 从流中查找一个满足条件的数据
    // Integer integer = stream.findFirst().get();
    // Integer integer = stream.findAny().get();
}

3. 中间操作

private static void processOperationMap(){
     Stream<Integer> stream = getDataSource().stream();

     //map是一个映射，
     //将流中的元素一一替换，返回值可以是任意类型，可以和流中的泛型不同
     stream.distinct().limit(10).map(e->e*10+"!").forEach(System.out::println);
 }

 //跳过
 private static void processOperationSkip() {
     Stream<Integer> stream = getDataSource().stream();

     //skip，跳过count个元素，[count,length)
     stream.skip(10).forEach(System.out::println);
 }

 //截取
 private static void processOperationLimit() {
     Stream<Integer> stream = getDataSource().stream();

     //limit,截取指定数量的元素，[0,count)
     stream.limit(10).forEach(System.out::println);
 }

 //排序
 private static void processOperationSorted() {
     Stream<Integer> stream = getDataSource().stream();

     //排序
     //无参的使用的是对象实现的Comparable接口中的comparaTo方法比较
     stream.sorted().forEach(System.out::println);
     //有参，参数为Comparator
/      stream.sorted((n1,n2)->n2-n1).forEach(System.out::println);
 }

 //去重
 private static void processOperationDistinct() {
     Stream<Integer> stream = getDataSource().stream();
     //对流中的数据进行去重
     //去重的规则和HashSet相同
     stream.distinct().forEach(System.out::println);
 }

 //过滤
 private static void processOperationFilter() {
     Stream<Integer> stream = getDataSource().stream();

     //执行条件过滤
     //参数是：Predicate
     //Predicate是一个函数式接口，返回一个boolean
     stream.filter(n -> n > 50).forEach(System.out::println);

 }

//扁平化映射
private static void flatMapTest() {
    String[] strs = { "hello", "world" };

    // 这里是一个直接映射，将流中的元素（字符串），替换成了由这个字符串分解出来的字符数组。
    // 在映射结束后，流中的数据依然是两个，分别是两个字符数组
    // Arrays.stream(strs).map(String::toCharArray).forEach(ele -> System.out.println(Arrays.toString(ele)));

    // flatMap: 扁平化映射
    //          常用于map直接映射完成后，流中的数据是一个个的容器，而我们需要对容器中的元素进行处理
    //          此时，可以使用扁平化映射，将容器中的元素直接存入流中
    Arrays.stream(strs).map(str -> str.split(""))
            .flatMap(Arrays::stream)
            .distinct()
            .forEach(System.out::println);
}

//将集合中的元素按照规则映射成int型数据
private static void mapToIntTest() {
    List<String> list = new ArrayList<>();
    Collections.addAll(list, "lily", "lucy", "Uncle wang", "Jim", "xiaoming", "hanmeimei", "xiaoxiaohui", "xiaohuihui", "xiaobai");

    // 需求: 计算集合中所有的字符串的最大长度、最小长度、平均长度
    // IntStream:
    // sum()    : 求和
    // average(): 求平均值
    // max()    : 求最大值
    // min()    : 求最小值
    int max = list.stream().mapToInt(String::length).max().getAsInt();
    int min = list.stream().mapToInt(String::length).min().getAsInt();
    double average = list.stream().mapToInt(String::length).average().getAsDouble();

    // summaryStatistics: 的到对流中的数据的统计信息（包含了数量、和、最大值、最小值、平均值）
    IntSummaryStatistics intSummaryStatistics = list.stream().mapToInt(String::length).summaryStatistics();
    System.out.println(intSummaryStatistics);
    System.out.println("最大值: " + intSummaryStatistics.getMax());
    System.out.println("最小值: " + intSummaryStatistics.getMin());
    System.out.println("平均值值: " + intSummaryStatistics.getAverage());
    System.out.println("和: " + intSummaryStatistics.getSum());
    System.out.println("数量: " + intSummaryStatistics.getCount());

}