Stream流的api方法

「爱情、让人受尽委屈。」 2024-03-16 18:11 46阅读 0赞

### 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][]

[17b30e7c14824de0b1da446bf6505f34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a0457b20b88c4f73893dfbbc4c23a056.png
[f6a6d98850924c8cae8d963ac01a2fcf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b9cab68367194f9cbbd4bdba84e885e8.png
[33a4fcdbbb224a0e903a3b6274e09bc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/d90086a85c5d46a19e037d00c5f50df1.png