JDK1.8新特性---＞stream流

JDK1.8新特性—>stream流

创建流的三种方式

1. 静态方法流、集合流、数据流

   // 静态方法流
   Stream.of(1, 2, 3, 4);
   // 集合流
   new ArrayList<>().stream();
   // 数组流
   Arrays.stream(new int[5]);
   

Stream测试

1. Person类

   package com.xiaoge.stream;
   
   import lombok.*;
   
   /**
    * @Classname Person
    * @Date 2022/8/5 9:43
    * @Created by ZhangXiao
    * @Description TODO
    */
   @ToString
   @AllArgsConstructor
   @NoArgsConstructor
   @Data
   @Builder
   public class Person {
   
       private String name;
   
       private Integer age;
   
       private String sex;
   
   }
   

2. StreamTest类

   /**
    * @Classname StreamTest
    * @Date 2022/8/5 9:42
    * @Created by ZhangXiao
    * @Description TODO
    */
   public class StreamTest {
   
       public static void main(String[] args) {
           List<Person> list = new ArrayList<>();
   
           Person person1 = new Person("张三", 18, "男");
           Person person2 = new Person("李四", 20, "男");
           Person person3 = new Person("王五", 25, "女");
           Person person4 = new Person("赵七", 30, "男");
   
           list.add(person1);
           list.add(person2);
           list.add(person3);
           list.add(person4);
       }
   }
   

   map(): 对集合元素逐个进行函数操作，映射成全新的一个集合

   // 收集所有对象的age, 收集成一个list
   List<Integer> ages = list
       .stream()
       .map(Person::getAge)
       .collect(Collectors.toList());
   System.out.println(ages);
   
   // 结果
   [18, 20, 25, 30]
   

   flatMap():接收一个函数作为参数，将流中的值进行函数操作后，然后把所有流连接成一个流

   List<String> list = Arrays.asList("hello", "xiaoge");
   System.out.println(list);       
   
   List<String> collect1 = list
       .stream()
       .map(x -> x.split(""))
       .flatMap(Arrays::stream)
       .collect(Collectors.toList());
   
   System.out.println(collect1);
   
    // 结果
    [hello, xiaoge]
    [h, e, l, l, o, x, i, a, o, g, e]
   

   filter(): 按条件过滤

   List<Person> sexList = list
        .stream()
        .filter(person -> "女".equals(person.getSex()))
        .collect(Collectors.toList());
   System.out.println(sexList);
   
   // 结果
   [Person(name=王五, age=25, sex=女)]
   

   limit(): 按个数取出

   // 只取前面两个对象
   list.stream().limit(2).forEach(System.out::println);
   
   // 结果
   Person(name=张三, age=18, sex=男)
   Person(name=李四, age=20, sex=男)
   

   skip(): 跳过前(指定值)个截取

   // 跳过前2个截取
   list.stream().skip(2).forEach(System.out::println);
   
   // 结果
   Person(name=王五, age=25, sex=女)
   Person(name=赵七, age=30, sex=男)
   

   distinct(): 去重

   List<Person> list = new ArrayList<>();
   
   Person person1 = new Person("张三", 18, "男");
   Person person2 = new Person("李四", 20, "男");
   Person person3 = new Person("王五", 25, "女");
   Person person4 = new Person("赵七", 30, "男");
   Person person5 = new Person("赵七", 30, "男");
   
   list.add(person1);
   list.add(person2);
   list.add(person3);
   list.add(person4);
   list.add(person5);
   
   // 去重
   list.stream().distinct().forEach(System.out::println);
   
   
   // 结果
   Person(name=张三, age=18, sex=男)
   Person(name=李四, age=20, sex=男)
   Person(name=王五, age=25, sex=女)
   Person(name=赵七, age=30, sex=男)
   

   sorted(): 排序，可自定义排序

   List<Person> list2 = list.stream()
       .sorted((x, y) -> {
           return x.getAge().compareTo(y.getAge());
       }).collect(Collectors.toList());
   
   System.out.println(list2);
   
   
   
   // 使用Comparator.comparing排序
   List<Person> list2 = list.stream().sorted(Comparator.comparing(Person::getAge))
                .collect(Collectors.toList());
                
                
   // 使用Comparator.comparing逆序排序
   List<Person> list2 = list.stream().sorted(Comparator.comparing(Person::getAge).reversed())
                .collect(Collectors.toList());
   
   
   /**
    *  创建了一个普通的HashMap对象  map ，并向其中插入一些键值对。
    *  然后，我们创建一个新的有序的LinkedHashMap对象  sortedMap 。
    *  使用Stream的 sorted() 方法和 Map.Entry.comparingByValue() 比较器，对Map的entry按值进行排序。
    *  最后，我们使用 forEachOrdered() 方法将排序后的entry逐个放入有序的Map  sortedMap  中。 
    *  运行上述代码后，将输出有序的Map  {A=1, B=2, C=3, D=4} ，即根据Map的值进行排序后得到的有序Map。
    */
   // map排序根据key/value进行排序成有序map
   Map<String, Integer> map = new HashMap<>();
   map.put("C", 3);
   map.put("A", 1);
   map.put("B", 2);
   map.put("D", 4);
   // 根据value排序成有序Map
   Map<String, Integer> sortedMap = new LinkedHashMap<>();
   map.entrySet().stream()
           .sorted(Map.Entry.comparingByValue())
           .forEachOrdered(entry -> sortedMap.put(entry.getKey(), entry.getValue()));
   System.out.println(sortedMap); 
   
   //  运行结果
   {A=1, B=2, C=3, D=4}
   
   Map<String, Integer> map = new HashMap<>();
   map.put("C", 3);
   map.put("A", 1);
   map.put("B", 2);
   map.put("D", 4);
   // 根据key排序成有序Map
   Map<String, Integer> sortedMap = new LinkedHashMap<>();
   map.entrySet().stream()
           .sorted(Map.Entry.comparingByKey())
           .forEachOrdered(entry -> sortedMap.put(entry.getKey(), entry.getValue()));
   System.out.println(sortedMap); 
   
   //  运行结果
   {A=1, B=2, C=3, D=4}
   

   Collectors.toMap: 自定义组装Map (toList/toSet忽略太简单)

   Map<String, Integer> map = list
   	.stream()
   	.collect(Collectors.toMap(Person::getName, Person::getAge));
   
   map.forEach((key, value) -> {
       System.out.println("key: " + key + " value: " + value);
   });
   
   // 结果
   key: 李四 value: 20
   key: 张三 value: 18
   key: 王五 value: 25
   key: 赵七 value: 30
   
   /**
    *
    *  IntStream.range 用法
    *
    * IntStream.range(0, list.size()).boxed() 是一个用于生成从0到 list 的大小（不包括 list 的大小）的整数范围的Stream。 
    * IntStream.range()  方法返回一个IntStream，表示一个连续的整数序列。在这个例子中，我们使用 range(0, list.size()) 生成了一个从0到 list 的大小之间的整数范围（不包括 list 的大小）。 
    * 然后，我们使用 boxed() 方法将IntStream转换为Stream，
    * 将基本类型的整数流转换为包装类型的整数流。
    * 这是因为 Collectors.toMap() 方法需要操作包装类型的流，而不是基本类型的流。 
    * 因此， IntStream.range(0, list.size()).boxed() 的目的是生成一个从0到 list 的大小之间的整数范围，并将其转换为一个Stream流，
    * 以便进行后续的操作，如使用 Collectors.toMap() 方法来收集元素。
    */
   System.out.println(IntStream.range(0, 10).boxed().collect(Collectors.toList()));
   // 运行结果
   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
   
   
   
   // List转map list的值作为key, 索引作为value  
   List<String> list = List.of("A", "B", "C", "D");
   Map<String, Integer> map = IntStream.range(0, list.size())
           .boxed()
           .collect(Collectors.toMap(
                   list::get,
                   index -> index
           ));
   System.out.println(map);
   
   // 结果
   {A=0, B=1, C=2, D=3}
   
   
   // Set转map set的值作为key, 索引作为value
   Set<String> set = Set.of("A", "B", "C", "D");
   Map<String, Integer> map = IntStream.iterate(1, i -> i + 1)
           .limit(set.size())
           .boxed()
           .collect(Collectors.toMap(
                   i -> set.toArray()[i - 1].toString(),
                   i -> i
           ));
   System.out.println(map);
   
   // 运行结果
   {A=2, B=1, C=4, D=3}
   
   
   /**
     * 转换成指定类型的map
     * number -> number                             key
     * number -> number * 2                         value
     * (oldValue, newValue) -> newValue             当遇到重复key的时候, 用新的值, 替换老的值
     * LinkedHashMap::new                          返回的类型
     */
    List<Integer> numbers = List.of(1, 2, 3, 4, 5);
    Map<Integer, Integer> linkedHashMap = numbers.stream()
            .collect(Collectors.toMap(
                    number -> number,
                    number -> number * 2,
                    (oldValue, newValue) -> newValue,
                    LinkedHashMap::new
            ));
    System.out.println(linkedHashMap);
    
    // 运行结果
    {1=2, 2=4, 3=6, 4=8, 5=10}
   
   List<Integer> numbers = List.of(1, 2, 3, 4, 5, 5);
   Map<Integer, Integer> linkedHashMap = numbers.stream()
           .collect(Collectors.toMap(
                   number -> number,
                   number -> number * 2,
                   (oldValue, newValue) -> newValue,
                   LinkedHashMap::new
           ));
   System.out.println(linkedHashMap);
   // 运行结果
   {1=2, 2=4, 3=6, 4=8, 5=10}
   

   Collectors.toCollection: 自定义转换集合类型

   List<String> list = List.of("A", "B", "C", "D");
   
   LinkedHashSet<String> linkedHashSet = list.stream().collect(Collectors.toCollection(LinkedHashSet::new));
   // 结果
   [A, B, C, D]
   
   LinkedList<String> linkedList = list.stream().collect(Collectors.toCollection(LinkedList::new));
    // 结果
   [A, B, C, D]
   

   Collectors.joining: 字符串拼接

   Stream<String> stream = Stream.of("Hello", "World", "Java");
   String result = stream.collect(Collectors.joining());
   System.out.println(result);  // 输出结果为 "HelloWorldJava"
   stream = Stream.of("Hello", "World", "Java");
   result = stream.collect(Collectors.joining(", "));
   System.out.println(result);  // 输出结果为 "Hello, World, Java"
   stream = Stream.of("Hello", "World", "Java");
   result = stream.collect(Collectors.joining(", ", "[", "]"));
   System.out.println(result);  // 输出结果为 "[Hello, World, Java]"
   

   Collectors.groupingBy:按条件进行分组

   Map<String, List<Person>> map = list
       .stream()
       .collect(Collectors.groupingBy(Person::getSex));
   map.forEach((key, value) -> {
       System.out.println("key: " + key + " value: " + value);
   });
   
   
   // 结果
   key: 女 value: [Person(name=王五, age=25, sex=女)]
   key: 男 value: [Person(name=张三, age=18, sex=男), Person(name=李四, age=20, sex=男), Person(name=赵七, age=30, sex=男)]
   

   查询匹配

   // 有一个或一个以上的元素满足函数参数计算结果为true
   boolean match = list.stream().anyMatch(x -> x.getAge() == 18);
   // 全部满足函数计算及结果为true
   boolean allMatch = list.stream().allMatch(x -> x.getAge() == 18);
   // 不包含有满足这个判断的元素或者流中元素为空的时候方法返回true
   boolean noneMatch = list.stream().noneMatch(x -> x.getAge() == 18);
   // 查找第一个
   Person person = list.stream().findFirst().get();
   // 正常情况下一般会取第一个元素，在并行流的情况下会随机取一个元素  list.parallelStream()并行流
   Person person5 = list.stream().findAny().get();
   // 数量
   long count = list.stream().count();
   // 年龄最大
   Person person6 = list.stream().max((x, y) -> x.getAge().compareTo(y.getAge())).get();
   // 年龄最小
   Person person7 = list.stream().min(Comparator.comparing(Person::getAge)).get();
   
   System.out.println(match);
   System.out.println(allMatch);
   System.out.println(noneMatch);
   System.out.println(person);
   System.out.println(person5);
   System.out.println(count);
   System.out.println(person6);
   System.out.println(person7);
   
   
   // 结果
   true
   false
   false
   Person(name=张三, age=18, sex=男)
   Person(name=张三, age=18, sex=男)
   4
   Person(name=赵七, age=30, sex=男)
   Person(name=张三, age=18, sex=男)
   

   reduce():将流中的数据反复结合起来得到一个值

   //ma->reduce
   Integer sum = list
       .stream()
       .map(Person::getAge)
       .reduce(Integer::sum).get();
   System.out.println(sum);
   
   //设置初始值
   List<Integer> list = Arrays.asList(1, 2, 3);
   System.out.println(list.stream().reduce(100, (x, y) -> x * y));
   
   //不设置初始值
   List<Integer> list = Arrays.asList(2, 2, 3);
   System.out.println(list.stream().reduce( (x, y) -> x * y));
   
   // 结果
   93
   600
   Optional[12]