Java的Stream流

小鱼儿 2024-03-16 18:13 36阅读 0赞

## 1. Stream ##

Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的Stream API表达式。==Stream 是Java8中处理集合的关键抽象概念==，它可以对==集合进行非常复杂的查找、过滤、筛选等操作.==

### 1.1 为什么使用stream流 ###

当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。我们来体验 集合操作数据的弊端，需求如下：

一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,成俊杰,张三丰
    需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据

package demo10;
    
    import java.util.ArrayList;
    import java.util.List;
    
    
    public class Test {
        public static void main(String[] args) {
    //        一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,成俊杰,张三丰
    
    //        需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据
            List<String> list=new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("程俊杰");
            list.add("张三丰");
    
            //1.拿到所有姓张的
            List<String> newList01=new ArrayList<>();
            for(String n:list){
                if(n.startsWith("张")){
                     newList01.add(n);
                }
            }
    
            //2.拿到名字长度为3个字的
            List<String> newList02=new ArrayList<>();
            for(String n:newList01){
                 if(n.length()==3){
                     newList02.add(n);
                 }
            }
    
            //3.打印这些数据
            for(String s:newList02){
                System.out.println(s);
            }
    
    
        }
    }

> 分析:
> 
> **循环遍历的弊端**
> 
> 这段代码中含有三个循环，每一个作用不同：
> 
> > 1.  首先筛选所有姓张的人；
> > 2.  然后筛选名字有三个字的人；
> > 3.  最后进行对结果进行打印输出。
> > 
> > 每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环 是做事情的方式，而不是目的。每个需求都要循环一次，还要搞一个新集合来装数据，如果希望再次遍历，只能再使 用另一个循环从头开始。
> > 
> > 那Stream能给我们带来怎样更加优雅的写法呢？

> **Stream初体验**

List<String> list=new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
            list.add("张三");
            list.add("程俊杰");
            list.add("张三丰");
    
            //
    list.stream().filter(t->t.startsWith("张")).filter(t->t.length()==3).forEach(item-> System.out.println(item));

### 1.2 Stream流的原理 ###

Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

![d5dd42aece56496ca108da453c844322.png][]

### 1.3 步骤 ###

(1)获取Stream流对象

(2) 中间操作---返回类型还是Stream流对象。

(3)终止操作---不在是Stream流对象

### 1.4 获取Stream流对象的方式 ###

> (1) 通过集合对象调用stream()
> 
> (2)通过Arrays获取stream流对象
> 
> (3)通过Stream流里面of方法

package demo11;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Stream;
    
    
    public class Test11 {
        public static void main(String[] args) {
            List<String> list=new ArrayList<>();
            list.add("张无忌");
            list.add("周芷若");
            list.add("赵敏");
    //        Stream<String> stream = list.stream();
    //        stream.forEach(System.out::println);
    //        //第二种使用Arrays工具类
    //        String[] arr={};
    //        Stream<String> stream1 = Arrays.stream(arr);
    //
    //        //第三种:Stream类
    //        Stream<Integer> stream2 = Stream.of(1, 2, 4, 7, 8);
            //上面的流都是串行流。并行流
            Stream<String> stringStream = list.parallelStream();
            stringStream.forEach(System.out::println);
        }
    }

### 1.5 Stream流的api方法 ###

> 举个简单的例子：
> 
> 假设有一个Person类和一个Person列表，现在有两个需求：1）找到年龄大于18岁的人并输出；2）找出所有中国人的数量。

@Data
    class Person {
        private String name;
        private Integer age;
        private String country;
        private char sex;
    
        public Person(String name, Integer age, String country, char sex) {
            this.name = name;
            this.age = age;
            this.country = country;
            this.sex = sex;
        }
    }
    public class Test {
        public static void main(String[] args) {
            List<Person> personList = new ArrayList<>();
            personList.add(new Person("欧阳雪",18,"中国",'F'));
            personList.add(new Person("Tom",24,"美国",'M'));
            personList.add(new Person("Harley",22,"英国",'F'));
            personList.add(new Person("向天笑",20,"中国",'M'));
            personList.add(new Person("李康",22,"中国",'M'));
            personList.add(new Person("小梅",20,"中国",'F'));
            personList.add(new Person("何雪",21,"中国",'F'));
            personList.add(new Person("李康",22,"中国",'M'));

>     //1. 年龄大于18 filter:过滤掉不满足条件的元素. forEach:输出元素. ---如果没有终止函数，那么中间函数的代码不会被执行。

personList.stream(). filter(item->{
                System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");
                return item.getAge()>18;
            }).forEach(System.out::println);
    
            //2. 找出中国人  并统计个数: count()
            long count = personList.stream().filter(item
              -> item.getCountry().equals("中国")).count();
            System.out.println("中国人:"+count);
        }
    }

> （2）找出年龄最大和最小

Person person = personList.stream().max(((o1, o2)
             -> o1.getAge() - o2.getAge())).get();
            Person person2 = personList.stream().min(((o1, o2) 
            -> o1.getAge() - o2.getAge())).get();
            System.out.println(person);
            System.out.println(person2);

(3)map-->

> 会把集合中的元素转化成另一种类型

![17b30e7c14824de0b1da446bf6505f34.png][]

personList.stream().filter(item->item.getCountry().equals("中国"))
        .map(item->new P(item.getName(),item.getAge()))
        .forEach(System.out::println);
    
        public class Test03 {
        public static void main(String[] args) {
    //        整数数组每个元素+3
            List<Integer> list = Arrays.asList(1, 17, 27, 7);
            list.stream().map(item->item+3).forEach(System.out::println);
    
            List<String> list2=Arrays.asList
                         ("hello","world","java","spring","springmvc");
            //字符串大写
            list2.stream().map(String::toUpperCase).forEach(System.out::println);
        }
    }

(4)收集 collect

> 把处理过的集合搜集成新的集合。

List<Person> personList = new ArrayList<>();
            personList.add(new Person("小梅",24,"中国",'F'));
            personList.add(new Person("欧阳雪",18,"中国",'F'));
            personList.add(new Person("Tom",24,"美国",'M'));
            personList.add(new Person("Harley",22,"英国",'F'));
            personList.add(new Person("向天笑",20,"中国",'M'));
            personList.add(new Person("李康",22,"中国",'M'));
            personList.add(new Person("Tom",21,"中国",'F'));
            personList.add(new Person("李康",22,"中国",'M'));
    
            //把Person-年龄大于20人--里面名称----新的集合。
            List<String> collect = personList.stream()
            .filter(item -> item.getAge() > 20)
            .map(item -> item.getName())
            .collect(Collectors.toList());
            System.out.println(collect);

（5）sorted排序

List<Person> collect = personList.stream()
       .sorted((o1, o2) -> o1.getAge() - o2.getAge())
       .collect(Collectors.toList());
    
            System.out.println(collect);

(6) reduce规约

> 归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

![f6a6d98850924c8cae8d963ac01a2fcf.png][]

> 整型集合: -----请求。\[1,2,3,4\]=
> 
>     List<Integer> list= Arrays.asList(1,2,3,5);Optional<Integer> reduce = list.stream().reduce((t1, t2) -> t1 * t2);//t1=1, t2=2 ===>2//t1=2  t2=3===>6//t1=6  t2=5====>30System.out.println(reduce.get());

> (7)查询第一个findFirst

Optional<Person> first = personList.stream()
          .filter(item->item.getAge()>=18&&item.getAge()<=20).findFirst();
            System.out.println(first.get());

> 1.  中间的操作: filter map sorted distinct() skip limit()
> 2.  终止操作: forEach count() reduce() collect(Collectors.toList()) findFirst
> 
> max min

>     
>     一个小例子

交易员类
    public class Trader {
        private  String name;
        private  String city;
    
        public Trader(String name, String city) {
            this.name = name;
            this.city = city;
        }
    
        public String getName() {
            return name;
        }
    
        public String getCity() {
            return city;
        }
    
        @Override
        public String toString() {
            return "Trader{" +
                    "name='" + name + '\'' +
                    ", city='" + city + '\'' +
                    '}';
        }
    }
    
    Transaction（交易记录）
    
    public class Transaction {
        private  Trader trader; //交易员
        private  int year;
        private  int value;
        public Transaction(Trader trader, int year, int value){
            this.trader = trader;
            this.year = year;
            this.value = value;
        }
        public Trader getTrader(){
            return this.trader;
        }
        public int getYear(){
            return this.year;
        }
        public int getValue(){
            return this.value;
        }
        public String toString(){
            return "{" + this.trader + ", " +
                    "year: "+this.year+", " +
                    "value:" + this.value +"}";
        }
    }
    Trader raoul = new  Trader("Raoul", "Cambridge");
            Trader mario = new Trader("Mario", "Milan");
            Trader alan = new Trader("Alan", "Cambridge");
            Trader brian = new Trader("Brian", "Cambridge");
    
            List<Transaction> transactions = Arrays.asList(
                    new Transaction(brian, 2011, 300),
                    new Transaction(raoul, 2012, 1000),
                    new Transaction(raoul, 2011, 400),
                    new Transaction(mario, 2012, 710),
                    new Transaction(mario, 2012, 700),
                    new Transaction(alan, 2012, 950)
            );

>     
>     (1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。输出结果
>     (2) 交易员都在哪些不同的城市工作过？ 
>     (3) 查找所有来自于剑桥的交易员，并按姓名排序。
>     (4) 返回所有交易员的姓名字符串，按字母顺序排序。
>     (5) 有没有交易员是在米兰工作的？
>     (6) 打印生活在剑桥的交易员的所有交易额。
>     (7) 所有交易中，最高的交易额是多少？
>     (8) 找到交易额最小的交易。
>     能使用方法引用的尽量用方法引用。

//(1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。输出结果
            List<Transaction> collect = transactions.stream().filter(item -> item.getYear() == 2011).sorted(Comparator.comparingInt(Transaction::getValue)).collect(Collectors.toList());
            System.out.println("1、"+collect);
    //        (2) 交易员都在哪些不同的城市工作过？
            List<String> collect1 = transactions.stream().map(item -> item.getTrader().getCity()).distinct().collect(Collectors.toList());
            System.out.println("2、"+collect1);
    //        (3) 查找所有来自于剑桥的交易员，并按姓名排序。
            List<String> cambridge1 = transactions.stream().filter(item -> item.getTrader().getCity().equals("Cambridge")).map(item -> item.getTrader().getName()).sorted(String::compareTo).distinct().collect(Collectors.toList());
            System.out.println("3、"+cambridge1);
    //        (4) 返回所有交易员的姓名字符串，按字母顺序排序。
            List<String> collect2 = transactions.stream().map(item -> item.getTrader().getName()).distinct().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());
            System.out.println("4、"+collect2);
    //        (5) 有没有交易员是在米兰工作的？
            boolean milan = transactions.stream().map(item -> item.getTrader().getCity()).anyMatch(("Milan"::equals));
            System.out.println("5、"+milan);
    //        (6) 打印生活在剑桥的交易员的所有交易额。
            List<Integer> cambridge = transactions.stream().filter(item -> item.getTrader().getCity().equals("Cambridge")).map(item -> item.getValue()).collect(Collectors.toList());
            System.out.println("6、"+cambridge);
            //        (7) 所有交易中，最高的交易额是多少？
            Integer integer1 = transactions.stream().map(item -> item.getValue()).max(Comparator.comparingInt(o -> o)).get();
            System.out.println("7、"+integer1);
    //        (8) 找到交易额最小的交易。
            Integer integer = transactions.stream().map(item -> item.getValue()).min(Comparator.comparingInt(o -> o)).get();
            System.out.println("8、"+integer);
    //        能使用方法引用的尽量用方法引用。
        }
    }

> **输出结果为：**

![33a4fcdbbb224a0e903a3b6274e09bc6.png][]

[d5dd42aece56496ca108da453c844322.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/acb0a32fa57245af8b21ba6403413d7f.png
[17b30e7c14824de0b1da446bf6505f34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/0b0ad513b9154a33991440bb0775d9cf.png
[f6a6d98850924c8cae8d963ac01a2fcf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/533c61ab72fe4f48bb36d8e1d39a5c93.png
[33a4fcdbbb224a0e903a3b6274e09bc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/904a15881ddc4fc288e44cf1858dc836.png