Java中Lambda表达式的使用

2022-05-09 21:33:59 阅读：191 来源： 互联网

标签：Java String System 接口 Lambda 表达式 out

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及java.util.stream 包。流(stream)就如同迭代器(iterator),但附加了许多额外的功能。总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。在本文中,我们将从简单到复杂的示例中见认识lambda表达式和stream的强悍。

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效

2 Lambda表达式的组成
java 8 中Lambda 表达式由三个部分组成：第一部分为一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数；第二部分为一个箭头符号：->；第三部分为方法体，可以是表达式和代码块。语法如下

1、方法体为表达式，该表达式的值作为返回值返回

// 求和
(parameters)  -> expression
(int a, int b) -> return a+b;

2、方法体为代码块，必须用 {} 来包裹起来，且需要一个 return 返回值，但若函数式接口里面方法返回值是 void，则无需返回值。

(parameters) -> { statements; }
(int a) -> {System.out.println("a = " + a);} //打印，无返回值
(int a) -> {return a * a;} //求平方

2.1 Lambda表达式的函数式接口

上面提到了函数式接口，那这是一个什么样的概念呢？

函数式接口(Functional Interface)是Java 8对一类特殊类型的接口的称呼。这类接口只定义了唯一的抽象方法的接口（除了隐含的Object对象的公共方法，因此最开始也就做SAM类型的接口（Single Abstract Method）。定义函数式接口的原因是在Java Lambda的实现中,开发组不想再为Lambda表达式单独定义一种特殊的Structural函数类型,称之为箭头类型（arrow type,依然想采用Java既有的类型(class, interface, method等).原因是增加一个结构化的函数类型会增加函数类型的复杂性，破坏既有的Java类型，并对成千上万的Java类库造成严重的影响。权衡利弊,因此最终还是利用SAM 接口作为 Lambda表达式的目标类型.另外对于函数式接口来说@FunctionalInterface并不是必须的,只要接口中只定义了唯一的抽象方法的接口那它就是一个实质上的函数式接口,就可以用来实现Lambda表达式。

在java 8中已经为我们定义了很多常用的函数式接口它们都放在java.util.function包下面,一般有以下常用的四大核心接口：

函数式接口参数类型返回类型用途
Consumer<T>(消费型接口) T void 对类型为T的对象应用操作。void accept(T t)
Supplier<T>(供给型接口) 无 T 返回类型为T的对象。 T get();
Function<T, R>(函数型接口) T R 对类型为T的对象应用操作并返回R类型的对象。R apply(T t);
Predicate<T>(断言型接口) T boolean 确定类型为T的对象是否满足约束。boolean test(T t);
函数式接口

Java 把 Lambda表达式当作是一个接口类型的实例。它把这种形式被称之为函数式接口。一个函数式接口就是一个只有单一方法的接口，Java把这种方法称之为“函数式方法”，但更常用的名字为单一抽象方法（single abstract method" 或 SAM）。例如JDK中存在的接口例如Runnable和Callable。

@FunctionalInterface

Oracle 引入了一个新的注解为@FunctionalInterface，用来标识一个接口为函数式接口。它基本上是用来传达这一用途，除此而外，编辑器还会做一些额外的检查。
比如，下面的接口：

public interface FunctionalInterfaceExample {
// compiles ok
}

如果加上@FunctionalInterface注解，则会编译错误：

@FunctionalInterface // <- error here
public interface FunctionalInterfaceExample {
// doesn't compile
}

编译器就会报错，错误的详细信息为“Invalid '@FunctionalInterface' annotation; FunctionalInterfaceExample is not a functional interface”。意思是没有定义一个单一的抽象方法。

而如果我们定义了两个抽象方法会如何？

@FunctionalInterface
public interface FunctionalInterfaceExample {
void apply();
void illegal(); // <- error here
}

编译器再次报错，提示为"multiple, non-overriding abstract methods were found"。所以，一旦使用了此注解，则在接口里只能定义一个抽象方法。

而现在有这样一种情况，如歌一个接口继承了另一个接口，会怎么办？我们创建一个新的函数式接口为A，定义了另一个接口B，B继承A，则B仍然是一个函数式接口，它继承了A的apply方法。

@FunctionalInterface
interface A {
abstract void apply();
}

interface B extends A {

如果你想看起来更加清晰，可以复写父类的方法：

@FunctionalInterface
interface A {
abstract void apply();
}

interface B extends A {
@Override
abstract void apply();
}

我们可以用下面的代码来测试一下上面的两个接口是否为函数式接口：

@FunctionalInterface
public interface A {
void apply();
}

public interface B extends A {
@Override
void apply();
}

public static void main(String... args) {
A a = () -> System.out.println("A");
B b = () -> System.out.println("B");
a.apply(); // 打印：A
b.apply(); // 打印：B
}

如果B接口继承了A接口，那么在B接口中就不能定义新的方法了，否则编译器会报错。

除了这些，在Java 8 中接口有了一些新的改进：

可以添加默认方法；
可以包含静态接口方法；
在java.util.function包中增加了一些新的接口，例如，Function 和 Predicate。
2.2 对接口的要求
虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法

jdk 8 中有另一个新特性：default，被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@FunctionalInterface#
修饰函数式接口的，要求接口中的抽象方法只有一个。这个注解往往会和 lambda 表达式一起出现

3 Lambda使用
3.1 基本使用
基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }

下面是Java 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)

基本的Lambda例子

现在,我们已经知道什么是lambda表达式,让我们先从一些基本的例子开始。在本节中,我们将看到lambda表达式如何影响我们编码的方式。假设有一个玩家List ,程序员可以使用 for 语句 ("for 循环")来遍历,在Java SE 8中可以转换为另一种形式:

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.print(player + "; "); 
} 

// 使用 lambda 表达式以及函数操作(functional operation) 
players.forEach((player) -> System.out.print(player + "; ")); 

// 在 Java 8 中使用双冒号操作符(double colon operator) 
players.forEach(System.out::println);

正如您看到的,lambda表达式可以将我们的代码缩减到一行。另一个例子是在图形用户界面程序中,匿名类可以使用lambda表达式来代替。同样,在实现Runnable接口时也可以这样使用:

// 使用匿名内部类 
btn.setOnAction(new EventHandler<ActionEvent>() { 
@Override 
public void handle(ActionEvent event) { 
System.out.println("Hello World!"); 
} 
}); 

// 或者使用 lambda expression 
btn.setOnAction(event -> System.out.println("Hello World!"));

下面是使用lambdas 来实现 Runnable接口的示例:

// 1.1使用匿名内部类 
new Thread(new Runnable() { 
@Override 
public void run() { 
System.out.println("Hello world !"); 
} 
}).start(); 

// 1.2使用 lambda expression 
new Thread(() -> System.out.println("Hello world !")).start(); 

// 2.1使用匿名内部类 
Runnable race1 = new Runnable() { 
@Override 
public void run() { 
System.out.println("Hello world !"); 
} 
}; 

// 2.2使用 lambda expression 
Runnable race2 = () -> System.out.println("Hello world !"); 

// 直接调用 run 方法(没开新线程哦!) 
race1.run(); 
race2.run();

Runnable 的 lambda表达式,使用块格式,将五行代码转换成单行语句。接下来,在下一节中我们将使用lambdas对集合进行排序。

使用Lambdas排序集合
在Java中,Comparator 类被用来排序集合。在下面的例子中,我们将根据球员的 name, surname, name 长度以及最后一个字母。和前面的示例一样,先使用匿名内部类来排序,然后再使用lambda表达式精简我们的代码。
在第一个例子中,我们将根据name来排序list。使用旧的方式,代码如下所示:

String[] players = {"Rafael Nadal", "Novak Djokovic", 
"Stanislas Wawrinka", "David Ferrer", 
"Roger Federer", "Andy Murray", 
"Tomas Berdych", "Juan Martin Del Potro", 
"Richard Gasquet", "John Isner"}; 

// 1.1 使用匿名内部类根据 name 排序 players 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.compareTo(s2)); 
} 
});
使用lambdas,可以通过下面的代码实现同样的功能:

// 1.2 使用 lambda expression 排序 players 
Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2)); 
Arrays.sort(players, sortByName); 

// 1.3 也可以采用如下形式: 
Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2))); 
其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :

// 1.1 使用匿名内部类根据 surname 排序 players 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" ")))); 
} 
}); 

// 1.2 使用 lambda expression 排序,根据 surname 
Comparator<String> sortBySurname = (String s1, String s2) -> 
( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) ); 
Arrays.sort(players, sortBySurname); 

// 1.3 或者这样,怀疑原作者是不是想错了,括号好多... 
Arrays.sort(players, (String s1, String s2) -> 
( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) ) 
); 

// 2.1 使用匿名内部类根据 name lenght 排序 players 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.length() - s2.length()); 
} 
}); 

// 2.2 使用 lambda expression 排序,根据 name lenght 
Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length()); 
Arrays.sort(players, sortByNameLenght); 

// 2.3 or this 
Arrays.sort(players, (String s1, String s2) -> (s1.length() - s2.length())); 

// 3.1 使用匿名内部类排序 players, 根据最后一个字母 
Arrays.sort(players, new Comparator<String>() { 
@Override 
public int compare(String s1, String s2) { 
return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); 
} 
}); 

// 3.2 使用 lambda expression 排序,根据最后一个字母 
Comparator<String> sortByLastLetter = 
(String s1, String s2) -> 
(s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)); 
Arrays.sort(players, sortByLastLetter); 

// 3.3 or this 
Arrays.sort(players, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));

就是这样,简洁又直观。在下一节中我们将探索更多lambdas的能力,并将其与 stream 结合起来使用。

3.2 使用Lambdas和Streams
Stream是对集合的包装,通常和lambda一起使用。使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst() 这样的方法就会结束链式语法。在接下来的例子中,我们将探索lambdas和streams 能做什么。我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:

public class Person { 

private String firstName, lastName, job, gender; 
private int salary, age; 

public Person(String firstName, String lastName, String job, 
String gender, int age, int salary) { 
this.firstName = firstName; 
this.lastName = lastName; 
this.gender = gender; 
this.age = age; 
this.job = job; 
this.salary = salary; 
} 
// Getter and Setter 
// . . . . . 
}

接下来,我们将创建两个list,都用来存放Person对象:

List<Person> javaProgrammers = new ArrayList<Person>() { 
{ 
add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000)); 
add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500)); 
add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800)); 
add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600)); 
add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200)); 
add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900)); 
add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300)); 
add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700)); 
add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000)); 
add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300)); 
} 
}; 

List<Person> phpProgrammers = new ArrayList<Person>() { 
{ 
add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550)); 
add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200)); 
add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600)); 
add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000)); 
add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100)); 
add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300)); 
add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100)); 
add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000)); 
add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600)); 
add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800)); 
} 
};

现在我们使用forEach方法来迭代输出上述列表:

System.out.println("所有程序员的姓名:"); 
javaProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 
phpProgrammers.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

我们同样使用forEach方法,增加程序员的工资5%:

System.out.println("给程序员加薪 5% :"); 
Consumer<Person> giveRaise = e -> e.setSalary(e.getSalary() / 100 * 5 + e.getSalary()); 

javaProgrammers.forEach(giveRaise); 
phpProgrammers.forEach(giveRaise);

另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员:

System.out.println("下面是月薪超过 $1,400 的PHP程序员:") 
phpProgrammers.stream() 
.filter((p) -> (p.getSalary() > 1400)) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 
我们也可以定义过滤器,然后重用它们来执行其他操作:

// 定义 filters 
Predicate<Person> ageFilter = (p) -> (p.getAge() > 25); 
Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400); 
Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender())); 

System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:"); 
phpProgrammers.stream() 
.filter(ageFilter) 
.filter(salaryFilter) 
.filter(genderFilter) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 

// 重用filters 
System.out.println("年龄大于 24岁的女性 Java programmers:"); 
javaProgrammers.stream() 
.filter(ageFilter) 
.filter(genderFilter) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
System.out.println("最前面的3个 Java programmers:"); 
javaProgrammers.stream() 
.limit(3) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName())); 


System.out.println("最前面的3个女性 Java programmers:"); 
javaProgrammers.stream() 
.filter(genderFilter) 
.limit(3) 
.forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

排序呢? 我们在stream中能处理吗? 答案是肯定的。在下面的例子中,我们将根据名字和薪水排序Java程序员,放到一个list中,然后显示列表:

System.out.println("根据 name 排序,并显示前5个 Java programmers:"); 
List<Person> sortedJavaProgrammers = javaProgrammers 
.stream() 
.sorted((p, p2) -> (p.getFirstName().compareTo(p2.getFirstName()))) 
.limit(5) 
.collect(toList()); 

sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName())); 

System.out.println("根据 salary 排序 Java programmers:"); 
sortedJavaProgrammers = javaProgrammers 
.stream() 
.sorted( (p, p2) -> (p.getSalary() - p2.getSalary()) ) 
.collect( toList() ); 

sortedJavaProgrammers.forEach((p) -> System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));

如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个更快的是min和max方法:

System.out.println("工资最低的 Java programmer:"); 
Person pers = javaProgrammers 
.stream() 
.min((p1, p2) -> (p1.getSalary() - p2.getSalary())) 
.get() 

System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary()) 

System.out.println("工资最高的 Java programmer:"); 
Person person = javaProgrammers 
.stream() 
.max((p, p2) -> (p.getSalary() - p2.getSalary())) 
.get() 

System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary())

上面的例子中我们已经看到 collect 方法是如何工作的。结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中:

System.out.println("将 PHP programmers 的 first name 拼接成字符串:"); 
String phpDevelopers = phpProgrammers 
.stream() 
.map(Person::getFirstName) 
.collect(joining(" ; ")); // 在进一步的操作中可以作为标记(token) 

System.out.println("将 Java programmers 的 first name 存放到 Set:"); 
Set<String> javaDevFirstName = javaProgrammers 
.stream() 
.map(Person::getFirstName) 
.collect(toSet()); 

System.out.println("将 Java programmers 的 first name 存放到 TreeSet:"); 
TreeSet<String> javaDevLastName = javaProgrammers 
.stream() 
.map(Person::getLastName) 
.collect(toCollection(TreeSet::new));
Streams 还可以是并行的(parallel)。 示例如下:

System.out.println("计算付给 Java programmers 的所有money:"); 
int totalSalary = javaProgrammers 
.parallelStream() 
.mapToInt(p -> p.getSalary()) 
.sum();

我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据。接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:

//计算 count, min, max, sum, and average for numbers 
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 
IntSummaryStatistics stats = numbers 
.stream() 
.mapToInt((x) -> x) 
.summaryStatistics(); 

System.out.println("List中最大的数字 : " + stats.getMax()); 
System.out.println("List中最小的数字 : " + stats.getMin()); 
System.out.println("所有数字的总和 : " + stats.getSum()); 
System.out.println("所有数字的平均值 : " + stats.getAverage());

4 Lambda 表达式好处

1.替代匿名内部类

毫无疑问，lambda表达式用得最多的场合就是替代匿名内部类，而实现Runnable接口是匿名内部类的经典例子。lambda表达式的功能相当强大，用()->就可以代替整个匿名内部类！请看代码：

这就是lambda表达式的好处之一，用极少的代码完成了之前一个类做的事情！

lambda表达式的最大好处之一就是减少了代码量。我们知道，lambda表达式只能与功能接口一起使用。例如，Runnable 是一个接口，因此我们可以轻松地应用lambda表达式。

2.使用lambda表达式对集合进行迭代

通过将行为作为方法中的参数传递来支持顺序和并行执行-通过在Java 8中使用Stream API，将函数传递给collection方法。现在，集合的职责是以顺序或并行的方式处理元素。

3.Stream操作

我们来认识一下Lambda的好兄弟Stream，这里的Stream并不是输入流和输出流（IO），而它也是jdk8后的新特性，是有关算法和计算的，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。
Stream就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。
简单来讲，Stream就是JAVA8提供给我们的对于元素集合统一、快速、并行操作的一种方式。它能充分运用多核的优势，以及配合lambda表达式、链式结构对集合等进行许多有用的操作。
1）filter（过滤）

2）Map（映射）

3）limit(截断)

对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素
4）distinct(去重)

对于Stream中包含的元素进行去重操作（去重逻辑依赖元素的equals方法），新生成的Stream中没有重复的元素
5）count（统计）

count方法是一个流的终点方法，可使流的结果最终统计，返回int，比如我们计算一下满足18岁的总人数

6）Collect（收集流的结果）

collect方法也是一个流的终点方法，可收集最终的结果

4.与函数式接口Predicate配合

除了在语言层面支持函数式编程风格，Java 8也添加了一个包，叫做 java.util.function。它包含了很多类，用来支持Java的函数式编程。其中一个便是Predicate，使用 java.util.function.Predicate 函数式接口以及lambda表达式，可以向API方法添加逻辑，用更少的代码支持更多的动态行为。Predicate接口非常适用于做过滤。

————————————————
版权声明：本文为CSDN博主「mocas_wang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/mocas_wang/article/details/118802896

标签：Java,String,System,接口,Lambda,表达式,out
来源： https://www.cnblogs.com/yrjns/p/16188806.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Java中Lambda表达式的使用