lambda&&stream

lambda

匿名函数 为了简化java的匿名内部类

事件监听ActionListener 接口（外部类）

内部类 类在其他地方用不到，索性就把这个类定义在类的内部使用

好处：1.内部可以使用外部类成员

           2.其他地方发现不了

             往往内部类只用一次，还需要创建一个内部类

             JAVA为了简化语法、

java2之前，函数/方法是不能当作参数传递的，必须将函数包装在对象中，

但是核心就是函数完成某个功能，还需要创建一个对象

JAVA2开始，对这一语法进行简化，

 

public static void main(String[] args) {
    ArrayList<String> arrayList=new ArrayList<>();
    arrayList.add("a");
    arrayList.add("c");
    arrayList.add("b");

  /*  arrayList.sort(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });*/
    //匿名内部列，为了减少类的创建
    //此功能核心compareTo方法，但是java是面向对象的，方法是不能独立存在的，必须将方法包装在对象中
    arrayList.sort((a,b)->{
        return a.compareTo(b);
    });
    System.out.println(arrayList);
    
}

stream

处理数据集合（数组，集合类）

对数组，集合类 进行各种操作（过滤，排序···）

stream处理数据大体过程

数组/集合类 -->流-->各种操作（排序，过滤···）--结果

数组和集合类更偏向于存储数据

stream更偏向于数据操作

1.获取操作

/*
流操作
1.获取流，把集合/数组转化为stream对象
*/
ArrayList<Integer> arrayList=new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
arrayList.add(5);
Stream<Integer> arr= arrayList.stream();


Integer[] arry=new Integer[]{1,2,3,4,5};
Stream<Integer> stream= Arrays.stream(arry);

Stream<Integer> stream1=Stream.of(1,2,3,4,5);

 

中间操作

filter：过滤流中的某些元素,

sorted(): 自然排序，流中元素需实现 Comparable 接口

distinct: 去除重复元素

limit(n): 获取 n 个元素

skip(n): 跳过 n 元素，配合

limit(n)可实现分页

map(): 将其映射成一个新的元素

/*
* 中间操作
   filter：过滤流中的某些元素,
   sorted(): 自然排序，流中元素需实现 Comparable 接口
   distinct: 去除重复元素
   limit(n): 获取 n 个元素
   skip(n): 跳过 n 元素，配合
   limit(n)可实现分页
   map(): 将其映射成一个新的元素
* */
public static void main(String[] args) {
    Integer[] arry=new Integer[]{1,2,3,3,2,4,5};
    Arrays.stream(arry)
            .filter((e)->{//过滤
                return e<5;
            })
            .sorted((o1,o2)->{//排序
                return o2-o1;
            })
            .distinct()//去重
            .forEach((e)->{//遍历
                System.out.println(e);
            });
    Stream<Integer> stream1=Stream.of(1,2,3,4,2,4,3,5);
    stream1.distinct()
            .limit(4)
            .skip(1)
            .forEach((e)->{
                System.out.println(e);
            });

终端操作

forEach: 遍历流中的元素

toArray:将流中的元素倒入一个数组

Min:返回流中元素最小值

Max:返回流中元素最大值

count:返回流中元素的总个数

Reduce:所有元素求和

anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false

allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false

findFirst：返回流中第一个元素

collect:将流中的元素倒入一个集合,Collection 或 Map

/*
 * 终端操作

 forEach: 遍历流中的元素
 toArray:将流中的元素倒入一个数组
 Min:返回流中元素最小值
 Max:返回流中元素最大值
 count:返回流中元素的总个数
 Reduce:所有元素求和
 anyMatch:接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
 allMatch:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
 findFirst：返回流中第一个元素
 collect:将流中的元素倒入一个集合,Collection 或 Map
 * */
 public static void main(String[] args) {
     Stream<Integer> stream1=Stream.of(1,2,3,4,2,4,3,5);
     /*stream1.distinct()
             .toArray();*/
    /*Integer max=stream1.max((o1,o2)->{
         return o1-o2;
     }).get();
     System.out.println(max);*/
  /*   Integer min=stream1.min((o1,o2)->{
         return o1-o2;
     }).get();
     System.out.println(min);*/
/*   long a=  stream1.distinct()
             .count();
     System.out.println(a);*/

     boolean res=stream1.anyMatch((e)->{
         return e>5;
     });
     System.out.println(res);
       boolean res=stream1.allMatch((e)->{
            return e>0;
        });
        System.out.println(res);
 }