java8新特性[5]：深入理解Java8 Lambda表达式

home

Java8新特性

java8新特性[5]：深入理解Java8 Lambda表达式

栏目:Java8新特性作者:admin 日期:2018-11-18 评论:0 点击: 7,625 次

一、Lambda表达式是什么？

Lambda表达式有两个特点：一是匿名函数，二是可传递。

匿名函数的应用场景是：
通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用Lambda表达式。lambda表达式所表示的匿名函数的内容应该是很简单的，如果复杂的话，干脆就重新定义一个函数了，使用lambda就有点过于执拗了。

可传递使用场景是：
就是将Lambda表达式传递给其他的函数，它当做参数，Lambda作为一种更紧凑的代码风格，使Java的语言表达能力得到提升。

二、Lambda表达式语法

Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符为"->"，该操作符被称为Lambda操作符或箭头操作符，它将Lambda分为两个部分：

左侧：指定了Lambda表达式所需要的所有参数
右侧：指定了Lambda体，即Lambda表达式所要执行的功能。

常见的语法格式：

语法格式一：无参，无返回值，Lambda体只需要一条语句。

1	Runnable r = () -> System.out.println("Hello Lambda!");

语法格式二：Lambda需要一个参数

1	Consumer<String> con = (x) -> System.out.println(x);

语法格式三：Lambda只需要一个参数时，参数的小括号可以省略

1	Consumer<String> con = x -> System.out.println(x);

语法格式四：Lambda需要两个参数，并且有返回值

Comparator<Integer> com = (x, y) -> {

System.out.println("函数式接口");

return Integer.compare(x, y);

};

语法格式五：当Lambda体只有一条语句时，return与大括号可以省略

1	Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

语法格式六：数据类型可以省略，因为可由编译器推断得出，称为类型推断

BinaryOperator<Long> operator = (Long x, Long y) -> {

System.out.println("实现函数接口方法");

return x + y;

};

三、Lambda表达式实战

实战1：线程

public class Test {

public static void main(String[] args) {

// Java8之前：

new Thread(new Runnable() {

public void run() {

System.out.println("hello world");

}

}).start();

// Java8方式：

new Thread(() -> System.out.println("hello world")).start();

}

实战2：集合元素的遍历

public class Test2 {

public static void main(String[] args) {

// Java8之前：

List<String> list1 = Arrays.asList("a", "b", "c", "d");

for (String str : list1) {

System.out.println(str);

}

// Java 8之后：

List list2 = Arrays.asList("a", "b", "c", "d");

list2.forEach(n -> System.out.println(n));

// 使用Java 8的方法引用更方便，方法引用由::双冒号操作符标示，

list2.forEach(System.out::println);

}

实战3：map函数。

map函数可以说是函数式编程里最重要的一个方法了。map的作用是将一个对象变换为另外一个。

import java.util.Arrays;

import java.util.List;

public class Test3 {

public static void main(String[] args) {

map();

}

public static void map() {

List<Double> cost = Arrays.asList(10.0, 20.0, 30.0);

cost.stream().map(x -> x + x * 0.05).forEach(x -> System.out.println(x));

}

实战4： reduce函数。

map的作用是将一个对象变为另外一个，而reduce实现的则是将所有值合并为一个。

import java.util.Arrays;

import java.util.List;

public class Test4 {

public static void main(String[] args) {

mapReduce();

}

public static void mapReduce() {

List<Double> cost = Arrays.asList(10.0, 20.0, 30.0);

double allCost = cost.stream().map(x -> x + x * 0.05).reduce((sum, x) -> sum + x).get();

System.out.println(allCost);

}

实战5：过滤

import java.util.Arrays;

import java.util.List;

import java.util.stream.Collectors;

public class Test5 {

public static void main(String[] args) {

filter();

}

public static void filter() {

List<Double> cost = Arrays.asList(10.0, 20.0, 30.0, 40.0);

List<Double> filteredCost = cost.stream().filter(x -> x > 25.0).collect(Collectors.toList());

filteredCost.forEach(x -> System.out.println(x));

}

实战6：Predicate过滤

import java.util.Arrays;

import java.util.List;

import java.util.function.Predicate;

public class Test6 {

public static void filter(List<String> languages, Predicate<String> condition) {

languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));

}

public static void main(String[] args) {

List<String> languages = Arrays.asList("Java", "Python", "scala", "Shell", "R");

System.out.println("Language starts with J: ");

filter(languages, x -> x.startsWith("J"));

System.out.println("\nLanguage ends with a: ");

filter(languages, x -> x.endsWith("a"));

System.out.println("\nAll languages: ");

filter(languages, x -> true);

System.out.println("\nNo languages: ");

filter(languages, x -> false);

System.out.println("\nLanguage length bigger three: ");

filter(languages, x -> x.length() > 4);

}