lambda与stream基础

lambda 表达式与Stream

lambda

1. 语法

   • () ->{}
   • () 中写参数 ,参数类型可省略, 因为Java支持类型推导
   • {} 中写逻辑代码块
   • 省略的情况略

2. 实例

   • public static void main(String[] args) {
     
             List<Person> list =new ArrayList<>();
             list.add(new Person(18,"小王",2000));
             list.add(new Person(16,"小李",1000));
             list.add(new Person(3,"老张",6000));
     
     
             Comparator<Person> comparator= ( p1, p2)->p2.age-p1.age;
             list.sort(comparator);
             System.out.println(list);
         }
     

3. 使用条件

   • 能够使用lambda的依据是必须有相应的函数接口(内部只有一个抽象方法的接口)

4. 方法引用

   • 我们常常使用lambda表达式创建匿名函数,但是如果我们想调用已存在的方法 实例如下

   •     list.forEach(System.out::println);
         list.forEach(x->System.out.println(x));
     

   • 类名::方法名

stream

stream API 是对集合对象功能的增强,是增强版的iterator ,因为iterator 只是串行地对集合进行遍历, 而stream 可以串行,并行地遍历集合 ,在大数据,效率方面优势明显,减少代码量显著

1. 传统集合过滤数据

     List<Person> list =new ArrayList<>();
           list.add(new Person(18,"小王",2000));
           list.add(new Person(16,"小李",1000));
           list.add(new Person(3,"老张",6000));
   
           List<Person> list2 =new ArrayList<>();
           //传统集合过滤数据
           for(Person person:list){
               if (person.age>=16){
                   list2.add(person);
               }
           }
           for(Person person:list2){
               System.out.println(person);
           }
   

2. 使用stream流方法

     list.stream().filter(x -> x.age >= 16).forEach(System.out::println);
   

   emmmm 这就是差距吧

3. 集合和stream的互相转换

   1. 集合->stream
      • Collection.stream()
      • Collection.parallelStream()
   2. Stream–>集合
      • Stream.collect(Collectors.toList())

4. Stream常用操作

   1. map 中间操作

      • 将一种类型的值映射为另一种类型的值,最终转换为一个新的stream流

      • String [] str ={"java","c++","python"};
        List<String> collect1 = Stream.of(str).map(String::toUpperCase).collect(Collectors.toList());
        System.out.println(collect1);
        

   2. filter 中间操作

      • 遍历并筛选出满足条件的的元素形成一个新的stream流,

      • List<String> collect2 = Stream.of(str).filter(x -> x.startsWith("j")).collect(Collectors.toList());
        System.out.println(collect2);
        

   3. count 终止操作

      • count是一个终止操作,用于统计Stream中地元素个数

      • long count = Stream.of(str).count();
        System.out.println(count);
        

   4. min 终止操作

      • 我感觉这里是有个坑的,min()需要传入一个比较器(比较对象),我觉得min()是选取排序好的的第一个对象返回

      • Optional<String> min = Stream.of(str).min((p1, p2) -> p2.compareTo(p1));
        System.out.println(min); //python  降序第一个
        
         Optional<String> min = Stream.of(str).min((p1, p2) -> p1.compareTo(p2));
         System.out.println(min);//c++     升序第一个
        

   5. max 终止操作

      • 和上面min一样, 返回排好序的最后一个对象

      • Optional<String> max = Stream.of(str).min((p1, p2) -> p1.compareTo(p2));
        System.out.println(min); //python  升序最后一个
        
        Optional<String> max = Stream.of(str).min((p1, p2) -> p2.compareTo(p1));
        System.out.println(min); //c++  降序最后一个