Java 8 Lambda 表达式
1.出现的背景
Java 是面向对象语言，除了部分简单数据类型，Java 中的一切都是对象，即使数组也是一种对象，每个类创建的实例也是对象。在 Java 中定义的函数或方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。 在 Java 8 以前，若我们想要把某些功能传递给某个方法，总要去写匿名类。 代码示例：
list.sort(new Comparator() { @Override public int compare(User o1, User o2) { return o1.getId()-o2.getId(); } }
在上面的例子里，为了对集合集合进行排序，我们为 Comparator 接口创建了一个它的匿名内部类对象，重写接口中的方法,来实现排序功能. 简而言之，在 Java 里将普通的方法或函数像参数一样传值并不简单，为此，Java 8 增加了一个语言级的新特性，名为 Lambda 表达式。
2.Lambda 表达式简介
Lambda 表达式是一个匿名函数，我们可以把 lambda 表达式理解为一段可以传递的代码（将代码段像数据一样传递）。使用它可以写出更简洁， 更灵活的代码。作为一种更紧凑的代码风格，使 java 语言的表达式能力得到的提升。 Lambda 表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。
3.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 中的 Lambda 表达式通常使用 (argument) -> {body}语法书写，例如：
//左侧：lambda 表达式的参数列表 //右侧：lambda 表达式中需要执行的功能，即 lambda 体 (arg1, arg2...) -> { body } (type1 arg1, type2 arg2...) -> { body }
以下是一些 Lambda 表达式的例子：
//无参数，无返回值，lambda 体中只有一行代码时，{}可以忽略 () -> System.out.println("Hello World"); //无参数，有返回值 () -> { return 3.1415 }; //有参数，无返回值 (String s) -> { System.out.println(s); } //有一个参数，无返回值 s -> { System.out.println(s); } //有多个参数，有返回值 (int a, int b) -> { return a + b; } //有多个参数，表达式参数类型可以不写，jvm 可以根据上下文进行类型推断 (a, b) -> { return a - b; }
4.什么是功能接口（Functional interface）
Lambda 表达式只支持函数式接口 也就是只有一个抽象方法的接口.功能接口是 java 8 中的新增功能，它们只允许一个抽象方法。这些接口也称为单抽象方法接口。Java 8 也引入了一个注释，即@FunctionalInterface，当你注释的接口违反了 Functional Interface 的契约时，它可以用于编译器级错误。 以下是自定义功能接口的示例：
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
}
正如其定义所述，功能接口只能有一个抽象方法。如果我们尝试在其中添加一个抽象方法，则会抛出编译时错误。例如：
@FunctionalInterface
public interface WorkerInterface {
public void doWork();
public void doMoreWork();
}
//案例:
@FunctionalInterface
public interface Shape {
void area(int a,int b);
}
Shape d = (a, b)->{System.out.println(a+b);};
d.area(1, 2);
课堂案例:
public class TestCar {
public static void main(String[] args) {
Car car1 = new Car(101, "car1");
Car car2 = new Car(102, "car2");
Car car3 = new Car(103, "car3");
Car car4 = new Car(104, "car4");
Car[] cars = {car2,car1,car4,car3};
/* java是面向对象的语言,向方法传递参数不能是单个函数.
sort需要一个比较的函数,只能创建一个对象,将方法包装在对象中传递
可以通过创建匿名内部类对象,将比较函数包装起来.
java8之后为了再次简化语法,推出lambda语言
lambda就是一个匿名函数,简化匿名内部类语法,
以后可以将匿名函数当做参数传递, 由java根据语言进行推断,补全常规代码
*/
/*Arrays.sort(cars, new Comparator<Car>() {
@Override
public int compare(Car o1, Car o2) {
return 0;
}
});*/
Arrays.sort(cars,(Car c1,Car c2)->{
return c1.getNum()-c2.getNum();
});
}
}
Java8Stream
什么是 Stream？
Stream 是 Java8 的新特性,它允许你以声明式的方式处理数据集合，可以把它看作是遍历数据集的高级迭代器。此外与 stream 与 lambada 表达示结合后编码效率与大大提高，并且可读性更强。 要澄清的是 java8 中的 stream 与 InputStream 和 OutputStream 是完全不同的概念. 简单案例:
public static void main(String[] args) {
List applestore = new ArrayList();
applestore.add(new Apple(1,"red",500,"河南"));
applestore.add(new Apple(2,"red",400,"陕西"));
applestore.add(new Apple(3,"green",300,"上海"));
applestore.add(new Apple(4,"green",200,"湖北"));
applestore.add(new Apple(5,"green",100,"湖南"));
}
//我们的需求是在 applestore 集合中找出红色苹果手机. 使用 Stream 流快速实现操作
List apples = applestore
.stream()
.filter(a -> a.getColor().equals("red"))
.collect(Collectors.toList());
这里使用的就是 Java8 中的 stream 流，使用的是声明性方式写的：说明想要完成什么（筛选，排序，取值），而不说明如何实现一个操作（for 循环）。同时可以将这些操作链接起来，达到一种流水线式的效果：
Java8 中的集合支持一个新的 Stream 方法，它会返回一个流。 什么是流呢？ 简单的定义，就是“从支持数据处理操作的源,生成的元素序列”。 元素列表:和集合一样，流也提供了一个接口,访问特定元素类型的一组有序值。 数据源 :获取数据的源，比如集合。 数据处理操作:流更偏向于数据处理和计算，比如 filter、map、find、sort 等。简单来说，我们通过一个集合的 stream 方法获取一个流，然后对流进行一系列流操作，最后再构建成我们需要的数据集合。 语法:
stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|+ Listt<Integer> list = widgets.stream() .filter(b -> b.getColor() == RED) .sorted((x,y) -> x.getWeight() - y.getWeight()) .sum();
获取流
//用 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();
流操作
流操作可以分为两类：中间操作和终端操作。回看之前的代码：
List<Apple> apples = applestore
.stream() //获得流
.filter(a -> a.getColor().equals("red")) //中间操作
.collect(Collectors.toList()); //终端操作
简化一下就是： 数据源 => 中间操作 => 终端操作 => 结果 诸如 filter 或者 sort 等中间操作会返回另一个流，进而进行下一步流操作，而终端操作则是将流关闭，构建新的数据集合对象（也可以不构建）。
中间操作
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 class StreamDemo3 {
/* Stream 流 是java8推出的新功能, 与IO流完全不同的.
提供了对象数据集合进行操作的各种方法,我们只需要声明式的告诉其应该做什么.
java中的集合,数组主要是存储数据,而Stream主要作用是对集合进行操作.
获取流 流的中间操作 终端操作
数据集合-->Stream-->filter-->Stream-->sorted-->流-->tolist/sum/max--->result
就是一个对集合进行遍历操作的高级迭代器. */
//获取流 中间操作 终端操作
public static void main(String[] args) {
Integer[] array = {4,2,1,3,1};
long count = Arrays.stream(array) //返回一个Stream对象
.distinct()
.sorted((a,b)->{return a-b;})
.limit(5)
.count();//终端操作,返回最终处理的结果
System.out.println(count);
Integer max = Arrays.stream(array) //返回一个Stream对象
.distinct()
.max((a,b)->{return a-b;})
.get();
System.out.println(max);
Integer sum = Arrays.stream(array) //返回一个Stream对象
.distinct()
.reduce((a,b)->{ return a+b;})
.get();
System.out.println(sum);
Object [] objs = Arrays.stream(array)
.distinct()
.toArray();
System.out.println(Arrays.toString(objs));
boolean b = Arrays.stream(array)
.distinct()
//.anyMatch((e)->{return e<5;});//只要有一个元素满足返回true
.allMatch((e)->{return e<5;}); //所有的元素都必须满足条件 返回true
System.out.println(b);
List<Integer> list= Arrays.stream(array)
.distinct()
.collect(Collectors.toList());
System.out.println(list);
}}
public static void main(String[] args) {
Car car1=new Car(101,"宝马1","红色");
Car car2=new Car(102,"宝马2","黑色");
Car car3=new Car(103,"宝马3","蓝色");
Car car4=new Car(104,"宝马4","白色");
Car car5=new Car(105,"宝马5","绿色");
Car[] cars = {car1,car2,car3,car4,car5};
List<Car> listcar = Arrays.stream(cars)
.sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
.filter((c)->{ return c.getColor().equals("红色");})
.collect(Collectors.toList());
System.out.println(listcar);
/* Set<Car> setcar = Arrays.stream(cars)
.sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
.collect(Collectors.toSet());
System.out.println(setcar);*/
Map<Integer,String> carmap = Arrays.stream(cars)
.sorted((c1,c2)->{ return c1.getNum()-c1.getNum();})
.collect(Collectors.toMap(Car::getNum, Car::getColor));
System.out.println(carmap);
List<Integer> listnum = Arrays.stream(cars)
.map(Car::getNum)
.collect(Collectors.toList());
System.out.println(listnum);
}}
原文地址：https://www.jb51.cc/wenti/3287077.html
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
