lambda和Stream

lambda

1.出现的原因：为了适应时代的潮流，只有语言不断的进步，才能不会被世界所淘汰，java1.8出现了lambda，Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段 可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。Lambda 表达式的本质只是一个“语法糖”,由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。

list.sort(new Comparator() {
 @Override 
public int compare(User o1, User o2) 
{ return o1.getId()-o2.getId(); } }

而使用lambda以后，我们可以这样写

list.sort((User o1, User o2)-> { return o1.getId()-o2.getId(); });

一行代码就可以结束，是不是比以前效率有所提高呢，这就是java语言的魅力之所在。

2.lambda表达式的结构：

• Lambda 表达式可以具有零个，一个或多个参数。
• 可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。例如 (int a,int b)与 (a,b)相同。
• 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。
• 空括号用于表示一组空的参数。例如 () -> 42。
• 当有且仅有一个参数时，如果不显式指明类型，则不必使用小括号例如 a -> return a*a。
• Lambda 表达式的正文可以包含零条，一条或多条语句。
• 如果 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。
• 如果 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

 注意：（参数）->{方法体}  功能存在时只允许存在一个抽象方法。

java是面向对象的语言，想方法传递参数不能是单个函数，sort需要一个比较的函数，只能创建一个对象，将方法包装在对象中传递，可以通过创建匿名内部类对象，将比较函数包装起来，java1.8之后再次简化语法，推出lambda语言。

3.lambda的特性：

• lambda函数是匿名的：所谓匿名函数，通俗地说就是没有名字的函数。lambda函数没有名字。
• lambda函数有输入和输出：输入是传入到参数列表argument_list的值，输出是根据表达expression计算得到的值。
• lambda函数一般功能简单：单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。由于其实现的功能一目了然，甚至不需要专门的名字来说明。
   

 Stream

1.什么是 Stream？

• 遍历集合时高级迭代器
• 是java1.8推出的新功能，与IO完全不同
• 提供了对象数据集合进行操作的各种办法，声明

 

 2.获取流：

使用 Collection 接口下的 stream()

List list = new ArrayList<>();

Stream stream = list.stream();

使用 Arrays 中的 stream() 方法，将数组转成流

Integer[] nums = new Integer[10];

Stream stream = Arrays.stream(nums);

使 用 Stream 中的静态方法：of()

Stream stream = Stream.of(1,2,3,4,5,6);

 使用 BufferedReader.lines() 方法，将每行内容转成流

BufferedReader reader=new BufferedReader(new FileReader("stream.txt"));

Stream lineStream = reader.lines();

 3.流操作

流操作可以分为两类： 中间操作 和 终端操作 。

List apples = applestore

.stream()          获得流

.filter(a -> a.getColor().equals("red"))      中间操作

.collect(Collectors.toList());            终端操作

 数据源 => 中间操作 => 终端操作 => 结果

中间操作

方法名	作用
filter（）	过滤流中的某些元素,
sorted()	自然排序，流中元素需实现 Comparable 接口
distinct（）	去除重复元素
limit(n)	获取 n 个元素
skip(n)	跳过 n 元素，配合 limit(n)可实现分页
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) {
        Car car1 = new Car(001, "宝马1", "红色");
        Car car2 = new Car(002, "宝马2", "黑色");
        Car car3 = new Car(003, "宝马3", "白色");
        Car car4 = new Car(004, "宝马4", "蓝色");
        Car car5 = new Car(002, "宝马2", "黑色");
        Car[] cars = {car1, car2, car3, car4, car5};//创建一个Car数组
        Collection listcar=  Arrays.stream(cars)//转换为流
                .distinct()//去重
                .filter((e)->{return e.getColor().equals("红色");})//筛剔元素
                .collect(Collectors.toList());//:将流中的元素倒入一个集合,Collection 或 Map
        System.out.println(listcar);//进行输出

//        Integer [] a={1,5,9,6,3,2,4,7,8};
//        Integer a1= Arrays.stream(a)
//                .sorted((b,c)->{return b-c;})
//                .reduce((c,b)->{return b+c;})//求和
//                .get();
//        System.out.println(a1);




//        Integer [] a={1,5,9,6,3,2,4,7,8};
//        Boolean a1= Arrays.stream(a)
//                .sorted((b,c)->{return b-c;})
//                .allMatch((e)->{return e<9;});//:接收一个 Predicate 函数，当流中每个元素都符合条件时才返 回 true，否则返回 false
//        System.out.println(a1);

//        Integer [] a={1,5,9,6,3,2,4,7,8};
//       Boolean a1= Arrays.stream(a)
//                .sorted((b,c)->{return b-c;})
//                .anyMatch((e)->{return  e<9;});//接收一个 Predicate 函数，只要流中有一个元素满足条件则返 回 true，否则返回 false
//        System.out.println(a1);
//


//        Integer [] a={1,5,9,6,3,2,4,7,8};
//        long a1= Arrays.stream(a)
//                .sorted((b,c)->{return b-c;})
//                .count();
//        System.out.println(a1);

//        Integer [] a={1,5,9,6,3,2,4,7,8};
//       Object [] a1= Arrays.stream(a)
//                .sorted((b,c)->{return b-c;})
//                .toArray();
//        System.out.println(Arrays.toString(a1));


//        Integer [] a={1,5,9,6,3,2,4,7,8};
//        Integer a1= Arrays.stream(a)
//                .sorted((b,c)->{return b-c;})
//                .max((c,b)->{return c-b;})
//                .get();
//        System.out.println(a1);

    }}