Java8 Stream流的理解与认识

最新推荐文章于 2023-07-13 11:32:44 发布

Amazing66

最新推荐文章于 2023-07-13 11:32:44 发布

阅读量586

点赞数

分类专栏：知识总结文章标签： java

原文链接：https://blog.youkuaiyun.com/mu_wind/article/details/109516995

版权

知识总结专栏收录该内容

44 篇文章

订阅专栏

总结

原地址： https://blog.youkuaiyun.com/mu_wind/article/details/109516995
原作者：@云深i不知处

1、获取当前方法名

Thread.currentThread().getStackTrace()[1].getMethodName()

2、Map.containsKey/Value ()

Map.containsKey (object.getxxx())
Map.containsValue (object.getxxx())
返回值是Boolean类型  判断参数中有没有与map中相同的键/值 相等的 如果有 返回true 反之 返回false
========================================================================
     @Test
    public void test1(){
        HashMap<String, Object> hashMap = new HashMap();
        hashMap.put("a",1);
        hashMap.put("b",2);
        if (hashMap.containsKey("c")){
            System.out.println("有这个key");
        }else {
            System.out.println("没有这个key");
        }
        if (hashMap.containsValue(1)){
            System.out.println("有这个value");
        }else {
            System.out.println("没有这个value");
        }
    }

===========================================================================
    输出结果
==============================================================================    
没有这个key
有这个value

3、箭头函数与lambda表达式

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)
    
===================================================================
      @Test
    public void test1(){
        String[] atp = {"Rafael Nadal",
                "Novak Djokovic",
                "Stanislas Wawrinka",
                "David Ferrer",
                "Roger Federer",
                "Andy Murray",
                "Tomas Berdych",
                "Juan Martin Del Potro"};
        List<String> players =  Arrays.asList(atp);
      //最原始的方法
       for (String player : players) {
            System.out.println(player);
        }

       //使用java8 lambda表达式 双冒号操作符
        players.forEach(System.out::println);

       // 使用 lambda 表达式以及函数操作(functional operation)  
        players.forEach((player)-> System.out.println(player+""));
}
   
=========================================================================
双冒号操作符
    
通常的情况下:
把 x -> System.out.println(x) 简化为 System.out::println 的过程称之为 eta-conversion
把 System.out::println 简化为 x -> System.out.println(x) 的过程称之为 eta-expansion
    
范式:
	类名::方法名
注意:
	方法后面并没有()
	懒加载方法是否调用要看调用方使用情况
=================================================================================
 实例
 	() -> new ArrayList<>();  可以替换为      ArrayList::new
        
 	person -> person.getAge()  替换为     Person::getAge

4、Optional类

Optional类完美解决了空指针异常的问题，它允许值为null  并且Stream流操作中默认就是Optional

5、使用Stream流来处理集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hsxvzdci-1633765105327)(E:/Typroa图片/image-20211008160739227.png)]

5.1、遍历/匹配（foreach/find/match）

    List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

    // 遍历输出符合条件的元素
    list.stream().filter(x -> x > 6).forEach(System.out::println);
    // 匹配第一个
    Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
    // 匹配任意（适用于并行流）
    Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
    // 是否包含符合特定条件的元素
    boolean anyMatch = list.stream().anyMatch(x -> x < 6);

	//foreach遍历
	List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("killBee", 7800, 21, "female", "Washington"));
    personList.add(new Person("Currey", 8200, 24, "female", "New York"));
	personList.forEach(x-> System.out.println(x));
	或者
    personList.forEach(System.out::println);

5.2、筛选（filter）

 public void filter(){
    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
    System.out.println(personList.stream()
                       .filter(x -> x.getSalary() >8000)
                       .map(Person::getName)
                       .collect(Collectors.toList()));
     
 ============================================================
[Tom, Anni, Owen]

5.3、聚合（max/min/count)

    public void max_min_count(){
    List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
    //求最长的字符串  Comparator.comparing(类名::属性名) 升序 然后通过max 查询最大值
    Optional<String> max = list.stream().max(Comparator.comparing(String::length));
    System.out.println(max.get());
}
===================================================================
    weoujgsd
===============================================================
    public void max_min_count(){
    List<Integer> list = Arrays.asList(1,2,3,4,5);
    //求最长的字符串  Comparator.comparing(类名::属性名) 升序 然后通过max 查询最大值
    Optional<Integer> max = list.stream().min(Integer::compareTo);
    System.out.println(max.get());
}
============================================================
    1    Max和min用法一样 
=====================================================
    public void max_min_count(){
    List<Person> personList = new ArrayList<Person>();
    personList.add(new Person("Tom", 8900, 23, "male", "New York"));
    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
    personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    personList.add(new Person("Owen", 9500, 25, "male", "New York"));
    personList.add(new Person("Alisa", 7900, 26, "female", "New York"));

    long l = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList()).stream().count();
    System.out.println(l);
}
=======================================================
  3
====================================================    
    count方法放在代码最后面执行 逻辑计算完成 进行计数
    max/min 方法 放在流之后 逻辑计算之前 并使用（）将逻辑计算包括

5.4、收集（collect）

从字面上理解就是将处理好的流收集起来最终形成一个值或者新的集合

基本上格式就是collect （Collectors.相应方法接口）

5.4.1、归集（toList/toSet/toMap）

将处理好的流数据整合成List、Set、Map类型的数据

 List<Integer> list = Arrays.asList(1, 6, 3, 4, 7, 6, 9, 6, 20,1,6);
 List<Integer> collect = list.stream().filter(x->x>3).collect(Collectors.toList());
 Set<Integer> collect1 = list.stream().filter(x->x>3).collect(Collectors.toSet());
=====================================================
	list:  [6, 4, 7, 6, 9, 6, 20, 6]
     set: [4, 20, 6, 7, 9]
=======================================================
     List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
		personList.add(new Person("Anni", 8200, 24, "female", "New York"));
    Map<String, Integer> map = personList.stream()
        .filter(x -> x.getSalary() > 5000)
        .collect(Collectors.toMap(Person::getName, Person::getSalary));
   //使用iterator循环遍历map 
Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
    while(iterator.hasNext()){
        Map.Entry<String, Integer> next = iterator.next();
        System.out.println("key:"+next.getKey()+"value:"+next.getValue());
    }    
====================================================================
   将查询结果转换为map并使用iterator循环遍历map
key:Tomvalue:8900
key:Annivalue:8200
key:Jackvalue:7000
key:Lilyvalue:7800
如果像这种类型
    entPubList.stream().collect(Collectors.toMap(TblEntPub::getEntOrgCode, a->a));  
value值 a代表的是TblEntPub整个实体对象对应的数据

5.4.2、统计(count/averaging)

计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble

    public void count_averaging(){    List<Person> personList = new ArrayList<Person>();    personList.add(new Person("Tom", 8900, 23, "male", "New York"));    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));    personList.add(new Person("Anni", 8200, 24, "female", "New York"));    //员工总和    Long count = personList.stream().collect(Collectors.counting());    System.out.println(count);    //工资平均数    Double AvgSalary = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));    System.out.println(AvgSalary);    //工资最大数    Optional<Integer> MaxSalary = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compareTo));    System.out.println(MaxSalary);    //工资总和    Integer SumSalary = personList.stream().collect(Collectors.summingInt(Person::getSalary));    System.out.println(SumSalary);    //所有信息    DoubleSummaryStatistics statistics = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));    System.out.println(statistics);}==================================================================count；4average：7975.0max：Optional[8900]sum：31900所有信息：    DoubleSummaryStatistics{    count=4, sum=31900.000000, min=7000.000000, average=7975.000000, max=8900.000000	}

5.4.3、分组与分区(partitioningBy/groupingBy)

分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。
分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组。

  List<Person> personList = new ArrayList<Person>();    personList.add(new Person("Tom", 8900, 23, "male", "New York"));    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));    personList.add(new Person("Lily", 7800, 21, "female", "Washington"));    personList.add(new Person("Anni", 8200, 24, "female", "New York"));    //将所有人按工资是否大于8000分为两个区    Map<Boolean, List<Person>> map = 	//personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));     //名字长度大于5的进行分组       Map<Boolean, List<Person>> map = personList.stream()        									.collect(Collectors                 							.groupingBy(x -> x.getName()                             				.length() > 4));    Iterator<Map.Entry<Boolean, List<Person>>> iterator = map.entrySet().iterator();    while (iterator.hasNext()){        Map.Entry<Boolean, List<Person>> next = iterator.next();        System.out.println(next.getValue());    }========================================================== 分区操作 按工资是否大于8000进行分区    [Person{name='Jack', salary=7000, age=25, sex='male', area='Washington'}, Person{name='Lily', salary=7800, age=21, sex='female', area='Washington'}]    [Person{name='Tom', salary=8900, age=23, sex='male', area='New York'}, Person{name='Anni', salary=8200, age=24, sex='female', area='New York'}]  名字长度大于5的进行分组 [Person{name='Tom', salary=8900, age=23, sex='male', area='New York'}, Person{name='Jack', salary=7000, age=25, sex='male', area='Washington'}]    [Person{name='killBee', salary=7800, age=21, sex='female', area='Washington'}, Person{name='Currey', salary=8200, age=24, sex='female', area='New York'}]

6、排序(sorted)

sorted，中间操作。有两种排序：如果是数字就比大小是字符就比较Ascll码值

sorted()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：Comparator排序器自定义排序

@Test    public void sort(){    List<Person> personList = new ArrayList<Person>();    personList.add(new Person("Tom", 8900, 23, "male", "New York"));    personList.add(new Person("Jack", 7000, 25, "male", "Washington"));    personList.add(new Person("killBee", 7800, 21, "female", "Washington"));    personList.add(new Person("Currey", 8200, 24, "female", "New York"));          //按工资排序 默认升序     List<String> list = personList.stream().sorted(Comparator.comparing(Person::getSalary))  		.map(person -> person.getName()+":"+person.getSalary())        .collect(Collectors.toList());             //按工资排序    reversed() 降序    List<String> list1 = personList.stream().sorted(Comparator.comparing(Person::getSalary)         .reversed()).map(person ->person.getName()+":"+person.getSalary())          .collect(Collectors.toList());            //自定义排序 先按工资升序 如果工资相等 再按年龄降序       List<String> list2 = personList.stream().sorted(Comparator.comparing(Person::getSalary)            .thenComparing(Person::getAge))     .map(person -> person.getName()+":"+person.getSalary()+"==>"+person.getAge())            .collect(Collectors.toList());  list.forEach(x-> System.out.println(x));    System.out.println("================================");    list1.forEach(x-> System.out.println(x));    System.out.println("================================");    list2.forEach(x-> System.out.println(x));}}====================================================================升序Jack:7000killBee:7800Currey:8200Tom:8900================================降序Tom:8900Currey:8200killBee:7800Jack:7000================================Jack:7000==>25killBee:7800==>21Currey:8200==>24Tom:8900==>23

java8还提供了其他的排序方法可以不使用stream流

    personList.sort((o1, o2) -> o1.getSalary()-o2.getSalary());    personList.forEach(x-> System.out.println(x));=====================================================Person{name='Jack', salary=7000, age=3, sex='male', area='Washington'}Person{name='killBee', salary=7800, age=4, sex='female', area='Washington'}Person{name='Currey', salary=8200, age=2, sex='female', area='New York'}Person{name='Tom', salary=8900, age=1, sex='male', area='New York'}其中 o1.getSalary()、o2.getSalary() 是获取比较的元素 中间用-隔开

中文状态下按照拼音排序

personList.sort(Comparator.comparing(Person::getName, (a,b) ->{//第一顺序：按字段拼音return Collator.getInstance(Locale.CHINESE).compare(a, b);}).thenComparing(Person::getAge, (a, b) ->{//第二顺序：按数字大小return a<b?-1:1;//按类型大小排序，再加反转}).thenComparingLong(Person::getAge).reversed());简化  personList.sort((a, b) ->{       return Collator.getInstance(Locale.CHINESE).compare(a.getName(), b.getName());   });==========================================================Person{name='阿姐', salary=7000, age=1, sex='male', area='a'}Person{name='阿张', salary=8900, age=1, sex='male', area='New York'}Person{name='梨花', salary=8200, age=2, sex='female', area='New York'}Person{name='徐福', salary=7800, age=4, sex='female', area='Washington'}