JDK8新特性---stream流

项目上用到了stream流，找篇blog，转载一下，介绍下Stream流的用法。

1 流概述
  流是 JDK8 新增的成员,允许以声明性方式处理数据集合,可以把 Stream 流看作是遍历数据集合的一个高级迭代器
  使用流的好处: 代码以声明性方式书写:说明想要完成什么,而不是说明如何完 成一个操作 可以把几个基础操作连接起来,来表达复杂的数据处理的流水 线,同时保持代码清晰可读

  流是什么?
  从支持数据处理操作的源生成元素序列.数据源可以是集合,数组 或 IO 资源
  从操作角度来看,流与集合是不同的. 流不存储数据值; 流的目的 是处理数据,它是关于算法与计算的. 如果把集合作为流的数据源,创建流时不会导致数据流动; 如果流 的终止操作需要值时,流会从集合中获取值; 流只使用一次 流中心思想是延迟计算,流直到需要时才计算值

流使用时一般包括三件事:
  1) 一个数据源(如集合)来执行一个查询;
  2) 一个中间操作链,形成一条流的流水线
  3) 一个终端操作,执行流水线,生成结果

2 Stream流的几种获得方式

public class Test01 {
    public static void main(String[] args) {
        //1 如何获得流,可以通过 Collection 集合,数据, 根据字面量获得流
        // 1.1 通过 Collection 获得流
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "aa", "hello", "jj", "dd", "mm", "test");
        Stream<String> stream1 = list.stream();
        System.out.println(stream1);
        stream1.forEach(System.out::println);

        //  1.2 根据数组获得流
        String[]data = {"zhangsan","lisi","wangwu"};
        Stream<String> stream2 = Arrays.stream(data);
        stream2.forEach(s -> System.out.print(s + " "));
        System.out.println();

        // 1.3 直接通过值获得流
        Stream<String> stream3 = Stream.of("1", "2", "3", "4");
        stream3.forEach(s -> System.out.print(s + " "));
        System.out.println();

        // 1.4 无限流
        Stream.iterate(100, x -> x + 3).limit(10).forEach(s -> System.out.print(s + " "));
        System.out.println();
    }
}

 3 Stream流的筛选操作

public class Test01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "aa", "aa", "cc", "d","bb");

        Stream<String> stream = list.stream();

        //流的筛选与切片
        //去重:distinct()
        stream.distinct().forEach(System.out::println);
        System.out.println("-------------1-----------");

        //过滤filter(Predicate<? super T> predicate); 传递一个Predicate接口
        //   stream.filter(x -> x.length()>2).forEach(System.out::println);

        //java.lang.IllegalStateException:  流只能使用一次

        list.stream().filter(x -> x.length() > 2).forEach(System.out::println);
        System.out.println("-------------2-----------");

        //sorted()排序操作  Comparator<? super T> comparator 传递一个Comparator接口
        list.stream().sorted(String::compareTo).forEach(System.out::println);
        System.out.println("-------------3-----------");

        //limt()截断操作
        list.stream().limit(5).forEach(System.out::println);
        System.out.println("--------------4----------");

        //skip()跳过
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("---------------5---------");

    }
}

 4 Stream流的map映射

public class Test02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee");

        //map(Function<? super T, ? extends R> mapper); 传递一个Function接口

        //为每个元素应用toUpperCase()把小写转换为大写
        list.stream().map(String::toUpperCase).forEach(System.out::println);

        //list每个每个元素的长度，然后拼接空格  2 2 2 2 1 6
        list.stream().map(String::length).map(len->len + " ").forEach(System.out::println);
        System.out.println("----------2-------");
        
        //转换为数值流
        List<Integer> integerList= Arrays.asList(54,1,78,90,345);
        IntStream intStream = integerList.stream().mapToInt(x->x);
        intStream.forEach(x->System.out.print(x+" "));

    }
}

5 Stream流的查找与匹配

public class Test03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee", "sssssss");

        //allMatch()判断流中所有的元素是否都匹配给定的谓词
        System.out.println(list.stream().allMatch(s -> s.length() > 3)); //false

        //anyMatch()判断流中是否有某个元素可以匹配指定的谓词
        System.out.println(list.stream().anyMatch(s -> s.equals("wkcto"))); //true

        //noneMathc()判断流中的元素是否都没有匹配指定谓词的
        System.out.println(list.stream().noneMatch(s -> s.equals("jj"))); //false

        //findAny()和findFirst()的返回值类型均为Optional<T>

        //查找任意一个
        System.out.println(list.stream().filter(s -> s.length() > 5).findAny().get());

        //查找第一个
        try {
            System.out.println(list.stream().filter(s -> s.length() > 20).findFirst().get());
        }catch (Exception e) {
            e.printStackTrace();
        }

        //查找第一个，如果不加orElse 会输出Optional.empty
        System.out.println(list.stream().filter(s -> s.length() > 20).findFirst().orElse("不存在"));
    }
}

 6 Stream流的reduce规约

public class Test04 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "aa", "aa", "bb", "cc", "d", "eeeeee", "sssssss");

        //1 forEach 遍历
        list.stream().forEach(System.out::println);

        //2 cout 统计
        System.out.println(list.stream().filter(x -> x.length() > 2).count());

        //3 reduce 归纳合并
        //传递的是BinaryOperator<T> accumulator 接口
        Optional<String> reduce = list.stream().reduce((s1, s2) -> s1 + "--" + s2);

        System.out.println(reduce.get());
        //传递Consumer<? super T> consumer 接口
        reduce.ifPresent(System.out::println);

        //4数值操作
        List<Integer> list2 = Arrays.asList(6, 21, 87, 34, 1, 78, 54);

        //5求和,指定初始值
        //reduce(T identity, BinaryOperator<T> accumulator);
        System.out.println(list2.stream().reduce(0, Integer::sum));

        //求和,没有初始值
        //Optional<T> reduce(BinaryOperator<T> accumulator);
        System.out.println(list2.stream().reduce((x, y) -> x + y).orElse(0));

        //6最值
        //Optional<T> reduce(BinaryOperator<T> accumulator);
        System.out.println(list2.stream().reduce(Math::max).get());
        System.out.println(list2.stream().reduce(Math::min).get());
    }

 7 Stream流映射到数值流

public class Test05 {
    public static void main(String[] args) {
        List<Integer> list2 = Arrays.asList(6, 21, 87, 34, 1, 78, 54);

        //求和 IntStream mapToInt(ToIntFunction<? super T> mapper);
        System.out.println(list2.stream().mapToInt(x->x).sum() );

        //最大值 OptionalInt max(); 
        //public int getAsInt() {
        //  if (!isPresent) {
        //      throw new NoSuchElementException("No value present");
        //  }
        //      return value;
        // }
        System.out.println(list2.stream().mapToInt(x->x).max().getAsInt() );

        //最小值 OptionalInt min();
        //public int orElse(int other) {
        //    return isPresent ? value : other;
        //}
        System.out.println(list2.stream().mapToInt(x->x).min().orElse(0) );

        //平均值
        //DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
        //OptionalDouble average();
        System.out.println(list2.stream().mapToDouble(x->x).average().getAsDouble());
        
        
        //求最大值
        System.out.println(list2.stream().max(Integer::compareTo).get()); 
        
        //求最小值
        list2.stream().min(Integer::compareTo).ifPresent(System.out::println);
    }
}

 8 Stream流的collect规约

public class Test06 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "ss", "aa", "hello", "jj","hello","xx", "good");


        //把 stream 流转换为集合
        Set<String> stringSet = list.stream().collect(Collectors.toSet());
        System.out.println( stringSet );

        //把 Stream 流转换为数组
        Object[] objects = list.stream().toArray();
        System.out.println( Arrays.toString(objects));
        String[] toArray = list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(toArray));

        //Stream 流转换为字符串
        String collect = list.stream().collect(Collectors.joining(","));
        System.out.println(collect);
    }
}

————————————————
版权声明：本文为CSDN博主「ChengZi~」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_38339124/article/details/93423360