jdk新特性-Stream API

2024-03-28 10:44:52

Java Stream API
Stream 是一组用来处理数组、集合的API

Stream特性：
   1)   不是数据结构，没有内部存储
   2)   不支持索引访问
   3)   延迟计算
   4)   支持并行
   5)   很容易生成数组或集合（List、Set）
   6)   支持过滤、查找、转换；汇总、聚合等操作

Stream运行机制
   Stream分为源source、中间操作、终止操作

   流的源可以是一个数组、一个集合、一个生成器方法、一个I/O通道等等。

   一个流可以有零个或者多个中间操作，每一个中间操作都会返回一个新的流，供下一个操作使用。
   一个流只会有一个终止操作。

   Stream只有遇到终止操作，它的源才开始执行遍历操作。

Stream常用API
   创建：
       1) 通过数组
       2) 通过集合
       3) 通过Stream.generate方法来创建
       4) 通过Stream.iterate方法来创建
       5) 其他API创建
   中间操作：
       过滤 filter
       去重 distinct
       排序 sorted
       截取 limit、skip
       转换 map/flatMap
       其他 peek
   终止操作：
       循环 forEach
       计算 min、max、count、average
       匹配 anyMatch、allMatch、noneMatch、findFirst、findAny
       汇聚 reduce
       收集器 toArray collect

例：

public class StreamDemo {
   //Stream生成操作

   //1、通过数组生成
   static void gen1() {
       String[] strs = {"a","b","c","d"};
       Stream<String> stream = Stream.of(strs);
       stream.forEach(System.out::println);
   }

   //2、通过集合生成
   static void gen2() {
       List<String> list = Arrays.asList("1","2","3","4");
       Stream<String> stream = list.stream();
       stream.forEach(System.out::println);
   }

   //3、使用generate
   static void gen3() {
       Stream<Integer> generate = Stream.generate(() -> 1);
       generate.limit(10).forEach(System.out::println);
   }

   //4、使用iterator
   static void gen4() {
       Stream<Integer> iterate = Stream.iterate(1, x -> x + 1);
       iterate.limit(10).forEach(System.out::println);
   }

   //5、其他方式
   static void gen5() {
       String str = "abcdefg";
       IntStream stream = str.chars();
       stream.forEach(System.out::println);
   }

   public static void main(String[] args) {
       //Stream生成的操作
       //gen1();
       //gen2();
       //gen3();
       //gen4();
       //gen5();

       //中间操作：如果调用方法之后返回的结果是stream对象就意味着是一个中间操作

       //找出所有的偶数
       Arrays.asList(1,2,3,4,5,6).stream().filter((x)-> x%2 == 0).forEach(System.out::println);

       //求出所有结果集中偶数的和
       int sum = Arrays.asList(1,2,3,4,5,6,7,8,9).stream().filter((x)-> x%2 == 0).mapToInt(x->x).sum();
       System.out.println("和："+sum);

       //求集合中的最大值
       List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9);
       Optional<Integer> m = list.stream().max((a,b)->a-b);
       System.out.println("最大值："+m.get());

       //求集合中的最小值
       System.out.println("最小值："+list.stream().min((a,b)->a-b).get());

       //取集合中的任意值
       Optional<Integer> any = list.stream().filter(x -> x%2 == 0).findAny();
       System.out.println("任意值："+any.get());

       Optional<Integer> first = list.stream().filter(x -> x%2 == 0).findFirst();
       System.out.println("第一个："+first.get());

       Stream<Integer> intStream = list.stream().filter(x -> {
           System.out.println("运行代码");
           return x%2 == 0;
       });
       System.out.println(intStream.findFirst().get());

       //不使用max和min函数，获取最大值和最小值
       Optional<Integer> min1 = list.stream().sorted().findFirst();
       System.out.println("最小值："+min1.get());

       Optional<Integer> max1 = list.stream().sorted((a,b)-> b-a).findFirst();
       System.out.println("最大值："+max1.get());

       //按照自然顺序排序
       Arrays.asList("java","js","c","python").stream().sorted().forEach(System.out::println);
       //按照字符串长度排序
       Arrays.asList("java","js","c","python").stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);

       //将集合中的数据进行过滤然后返回一个集合对象
       List<Integer> collect = list.stream().filter(x->x%2==0).collect(Collectors.toList());
       collect.forEach(System.out::println);

       //去重操作
       System.out.println("去重操作：");
       Arrays.asList(1,2,3,3,2,4,5,1,4,6,5,7).stream().distinct().forEach(System.out::println);
       Arrays.asList(1,2,3,3,2,4,5,1,4,6,5,7).stream().collect(Collectors.toSet()).forEach(System.out::println);

       //打印20-30的集合数据
       Stream.iterate(1, x->x+1).limit(50).skip(19).limit(11).forEach(System.out::println);
       Stream.iterate(20, x->x+1).limit(11).forEach(System.out::println);

       String str = "11,22,33,44,55";
       System.out.println(Stream.of(str.split(",")).mapToInt(x->Integer.valueOf(x)).sum());
       System.out.println(Stream.of(str.split(",")).mapToInt(Integer::valueOf).sum());
       System.out.println(Stream.of(str.split(",")).map(x->Integer.valueOf(x)).mapToInt(x->x).sum());
       System.out.println(Stream.of(str.split(",")).map(Integer::valueOf).mapToInt(x->x).sum());

       //将str中的每一个数值打印出来，然后计算出最终的求和结果
       Stream.of(str.split(",")).peek(System.out::println).mapToInt(Integer::valueOf).sum();

       //创建一组自定义对象
       String str1 = "java,scala,python,js,******";
       Stream.of(str1.split(",")).map(x->new Person(x)).forEach(System.out::println);
       Stream.of(str1.split(",")).map(Person::new).forEach(System.out::println);
       Stream.of(str1.split(",")).map(x->Person.build(x)).forEach(System.out::println);
       Stream.of(str1.split(",")).map(Person::build).forEach(System.out::println);

       //allMatch 所有元素是否满足
       System.out.println(list.stream().allMatch(x->x>0));
   }

}

创建Person对象

public class Person {
   private String name;
   public Person() {
       super();
   }

   public Person(String name) {
       super();
       this.name = name;
   }

   public static Person build(String name) {
       Person p = new Person();
       p.setName(name);
       return p;
   }
   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   @Override
   public String toString() {
       return name;
   }
}

码农公寓

相关文章