java8新特性——Stream流

野性酷女 2023-10-13 08:15 93阅读 0赞

**目录**

Stream流的常用方法汇总：

常用方式

1.count方法：

2.filter方法：

4.limit方法:

3.concat方法

5、sorted方法（排序）

6、收集Stream流—把流转回想要转回的类型

7、parallel()

8、reduce(计算相加)

--------------------

### **Stream流的常用方法汇总：** ###

*  终结方法：返回值类型不再是Stream接口本身类型的方法，例如：forEach方法和count方法
 *  非终结方法/延迟方法：返回值类型仍然是Stream接口自身类型的方法，除了终结方法都是延迟方法。例如：filter,limit,skip,map,conat

<table> 
 <thead> 
  <tr> 
   <th>方法名称</th> 
   <th>方法作用</th> 
   <th>方法种类</th> 
   <th>是否支持链式调用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>count</td> 
   <td>统计个数</td> 
   <td>终结方法</td> 
   <td>否</td> 
  </tr> 
  <tr> 
   <td>forEach</td> 
   <td>逐一处理</td> 
   <td>终结方法</td> 
   <td>否</td> 
  </tr> 
  <tr> 
   <td>filter</td> 
   <td>过滤</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>limit</td> 
   <td>取用前几个</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>skip</td> 
   <td>跳过前几个</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>map</td> 
   <td>映射</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>concat</td> 
   <td>组合</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>sorted</td> 
   <td>排序</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>skip( long n)</td> 
   <td>丢弃流的第一个 n元素</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
  <tr> 
   <td>reduce</td> 
   <td>函数计算</td> 
   <td>函数拼接</td> 
   <td>是</td> 
  </tr> 
 </tbody> 
</table>

### 常用方式 ###

#### **1.count方法：** ####

long count (); 统计流中的元素，返回long类型数据

List<String> list = new ArrayList<>();
    			list.add("张老三");
    			list.add("张小三");
    			list.add("李四");
    			list.add("赵五");
    			list.add("张六");
    			list.add("王八");
    			long count = list.stream().count();
    	    System.out.println("集合中的元素个数是：" + count);
    
        输出结果：
            集合中的元素个数是：6

#### 2.filter方法： ####

Stream<T> filter(Predicate<? super ?> predicate); 过滤出满足条件的元素

参数Predicate：函数式接口，抽象方法：boolean test （T t)Predicate接口：是一个判断接口

// 获取stream流
            Stream<String> stream = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
            // 需求：过去出姓张的元素
            stream.filter(name->name.startsWith("张")).forEach(name->{
                System.out.println("流中的元素" + name);
            });

#### 4.limit方法: ####

Stream<T> limit(long maxSize); 取用前几个元素

注意： 参数是一个long 类型，如果流的长度大于参数，则进行截取；否则不进行操作

// 获取流的长度
            Stream<String> stream1 = Stream.of("张老三", "张小三", "李四", "赵五", "刘六", "王七");
            // 需求：保留前三个元素
            stream1.limit(3).forEach((String name)->{
                System.out.println("流中的前三个元素是：" + name);
            });
     
            输出结果：
                流中的前三个元素是：张老三
                流中的前三个元素是：张小三
                流中的前三个元素是：李四

#### **3.concat方法** ####

public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)--> 合并两个流

把list集合转为Map分组<String,List> ,key(属性)，value(list同属性值对象)

`Map<String, List<Employee>> map = emps.stream().collect(Collectors.*groupingBy*(Employee::getCity));`

Stream<String> stream1 = Stream.of("11","22","33","44","55");
            Stream<String> stream2 = Stream.of("张颜宇", "张三", "李四", "赵五", "刘六", "王七");
     
            // 需求：合并两个流
            Stream<String> stream = Stream.concat(stream1,stream2);
            stream.forEach((String name)->{
                System.out.print(name);
            });
     
            输出结果：
                1122334455张颜宇张三李四赵五刘六王七

**4.分组**

Collectors.groupingBy(分组条件，流对象)

流对象可进行二次操作

Map<String, List<Student>> collect1 = studentStream.collect(Collectors.groupingBy(s -> {
                if (s.getScore() >= 60) {
                    return "及格";
                } else {
                    return "不及格";
                }
            }));
    
    //多级分组
    Map<Integer, Map<String, List<Student>>> collect1 = studentStream.collect(Collectors.groupingBy(Student::getScore, Collectors.groupingBy(item -> {
                if (item.getAge() > 60) {
                    return "及格";
    
                } else {
                    return "不及格";
                }
            })));

#### 5、sorted方法（排序） ####

List<Vo>list=list.stream()
        .sorted(Comparator.comparing(Vo::getName))
        .collect(Collectors.toList());

使用vo对象的Name字段进行排序，最后在返回集合

#### 6、**收集Stream流—把流转回想要转回的类型** ####

`List<String> collect = Stream.concat(stream2, stream).collect(Collectors.toList());`

`List<String> b = list2.stream()`

`.filter(add -> add.startsWith("张")).collect(Collectors.toList());`

Stream流中提供了一个方法，可以把流中的数据收集到单例集合中

<R, A> R collect(Collector<? super T, A, R> collector); 把流中的数据手机到单列集合中 返回值类型是R。R指定为什么类型，就是手机到什么类型的集合 参数Collector<? super T, A, R>中的R类型，决定把流中的元素收集到哪个集合中 参数Collector如何得到 ？，可以使用 java.util.stream.Collectors工具类中的静态方法： - public static <T> Collector<T, ?, List<T>> toList()：转换为List集合 - public static <T> Collector<T, ?, Set<T>> toSet() ：转换为Set集合

List<String> list2 = new ArrayList<>();
            list2.add("张老三");
            list2.add("张小三");
            list2.add("李四");
            list2.add("赵五");
            list2.add("张六");
            list2.add("王八");
     
            // 需求：过滤出姓张的并且长度为3的元素
            Stream<String> stream = list2.stream().filter((String name) -> {
                return name.startsWith("张");
            }).filter((String name) -> {
                return name.length() == 3;
            });
     
            // stream 收集到单列集合中
            List<String> list = stream.collect(Collectors.toList());
            System.out.println(list);
     
            // stream 手机到单列集合中
            Set<String> set = stream.collect(Collectors.toSet());
            System.out.println(set);

#### 7、`parallel`() ####

多线程并行计算

public static void main(String[] args) {
            Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
                    .parallel()
                    .reduce((a, b) -> {
                        System.out.println(String.format("%s: %d + %d = %d",
                                Thread.currentThread().getName(), a, b, a + b));
                        return a + b;
                    }).ifPresent(System.out::println);
        }

#### 8、reduce(函数计算) ####

reduce可以通过**BigDecimal**实现把数值进行计算。

以add为例，可以把结果进行累计汇总。

public static void main(String[] args) {
            User user1 = new User(new BigDecimal(100));
            User user2 = new User(new BigDecimal(200));
    
            List<User> list = Arrays.asList(user1, user2);
            BigDecimal bigDecimal = list.stream().map(User::getVal).reduce(BigDecimal::add).get();
            System.out.println(bigDecimal);
        }
        static class User{
            private BigDecimal val;
    
            public User(BigDecimal val) {
                this.val = val;
            }
    
            public void setVal(BigDecimal val) {
                this.val = val;
            }
    
            public BigDecimal getVal() {
                return val;
            }
        }