一, Lambda 表达式是什么?
Lambda 表达式有两个特点: 一是匿名函数; 二是可传递.
匿名函数的应用场景是:
通常在需要一个函数, 但又不想费神去命名一个函数的场合下使用. Lambda 表达式所表示的匿名函数的内容应该是很简单的, 如果复杂的话, 干脆就去重新定义一个函数了.
可传递的应用场景是:
就是将 Lambda 表达式作为参数传递给其他函数, Lambda 表达式作为一种更紧凑的代码风格, 使 Java 的语言表达能力能到提升.
二, Lambda 表达式语法
Lambda 表达式在 Java 语言中引入了一个新的语法元素和操作符. 这个操作符是 "->", 该操作符被称为 Lambda 操作符或箭头操作符, 它将 Lambda 分为两个部分:
左侧: 指定了 Lambda 表达式所需要的所有参数
右侧: 制定了 Lambda 体, 即 Lambda 表达式所要执行的功能.
三, Lambda 表达式常见的语法格式
3.1, 无参, 无返回值, Lambda 体只需要一条语句.
Runnable r = () -> System.out.println("Hello Lambda!");
3.2,Lambda 需要一个参数
Consumer<String> con = (x) -> System.out.println(x);
3.3,Lambda 只需要一个参数时, 参数的小括号可以省略
Consumer<String> con = x -> System.out.println(x);
3.4,Lambda 需要两个参数, 并且有返回值
- Comparator<Integer> com = (x, y) -> {
- System.out.println("函数式接口");
- return Integer.compare(x, y);
- };
3.5, 当 Lambda 体只有一条语句时, return 与大括号可以省略
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
3.6, 数据类型可以省略, 因为可由编译器推断得出, 称为类型推断
- BinaryOperator<Long> operator = (Long x, Long y) -> {
- System.out.println("实现函数接口方法");
- return x + y;
- };
四, Lambda 表达式实战
4.1, 实现一个多线程
new Thread(() -> System.out.println("In Java8!")).start();
4.2, 遍历 list 集合
- List<Integer> list = new ArrayList<>();
- list.add(1);
- list.add(2);
- list.add(3);
- // 直接打印
- list.forEach(System.out::println);
- // 取值分别操作
- list.forEach(i -> {
- System.out.println(i * 3);
- });
4.3,map 函数, 允许将对象进行转换. 比如, 可以更改 list 中的每个元素的值
- List<Integer> list = Arrays.asList(1, 2, 3);
- // 可改变对象
- list.stream().map((i) -> i * 3).forEach(System.out::println);
- // 不可改变原有对象
- list.forEach(i -> i = i * 3);
- list.forEach(System.out::println);
4.4,reduce 函数, 用来将值进行合并, map 和 reduce 函数式函数式变成的核心.
- List<Integer> list = Arrays.asList(1, 2, 3);
- Integer integer = list.stream().map((i) -> i = i * 3).reduce((sum, count) -> sum += count).get();
- System.out.println(integer);
reduce 的更多用法
- // 字符串连接, concat = "ABCD"
- String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
- // 求最小值, minValue = -3.0
- double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
- // 求和, sumValue = 10, 有起始值
- int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
- // 求和, sumValue = 10, 无起始值
- sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
- // 过滤, 字符串连接, concat = "ace"
- concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z")> 0).reduce("", String:concat);
4.5, 过滤
过滤是 Java 开发者在大规模集合上的一个常用操作, 而现在使用 lambda 表达式和流 API 过滤大规模数据集合是惊人的简单. 流提供了一个 filter() 方法, 接受一个 Predicate 对象, 即可以传入一个 lambda 表达式作为过滤逻辑. 下面的例子是用 lambda 表达式过滤 Java 集合, 将帮助理解.
- List<String> strList = Arrays.asList("abc", "eqwr", "bcd", "qb" , "ehdc", "jk");
- List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
- System.out.printf("Original List : %s, filtered list : %s %n", strList, filtered);
4.6,Predicate 接口
Predicate 是 jdk8 中的新增接口, 共有 5 个方法.
- and(Predicate<? super T> p)
- negate()
- or(Predicate<? super T> p)
- test(T t)
- xor(Predicate<? super T> p)
该接口除了 test 方法是抽象方法, 其余都是 default 方法, 该接口可接受一个 lambda 表达式, 其实就是实现了 test 接口的一个匿名类
- public static void main(String[] args) {
- List<String> languages = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
- System.out.println("Language which starts with J :");
- filter(languages, (str) -> ((String) str).startsWith("J"));
- System.out.println("Language which ends with a :");
- filter(languages, (str) -> ((String) str).endsWith("a"));
- System.out.println("Print all languages :");
- filter(languages, (str) -> true);
- System.out.println("Print no language :");
- filter(languages, (str) -> false);
- System.out.println("Print language whose length greater than 4:");
- filter(languages, (str) -> ((String) str).length()> 4);
- Predicate<String> startWithJ = (n) -> n.startsWith("J");
- Predicate<String> fourLength = (n) -> n.length() == 4;
- languages.stream().filter(startWithJ.and(fourLength)).forEach(System.out::println);
- }
- public static void filter(List<String> names, Predicate condition) {
- names.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + ""));
- }
4.7, 对列表的每个元素使用函数
- List<String> strList = Arrays.asList("abc", "eqwr", "bcd", "qb" , "ehdc", "jk");
- String collect = strList.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(","));
- System.out.printf("filtered list : %s %n", collect);
4.8, 使用 distinct 进行去重
- List<Integer> numbers = Arrays.asList(9, 10, 3, 4, 7, 3, 4);
- List<Integer> distinct = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
- System.out.printf("Original List : %s, Square Without duplicates : %s %n", numbers, distinct);
4.9, 计算最值和平均值
IntStream,LongStream 和 DoubleStream 等流的类中, 有个非常有用的方法叫做 summaryStatistics() . 可以返回 IntSummaryStatistics,LongSummaryStatistics 或者 DoubleSummaryStatistic s, 描述流中元素的各种摘要数据. 在本例中, 我们用这个方法来计算列表的最大值和最小值. 它也有 getSum() 和 getAverage() 方法来获得列表的所有元素的总和及平均值.
- // 获取数字的个数, 最小值, 最大值, 总和以及平均值
- List<Integer> primes = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
- IntSummaryStatistics stats = primes.stream().mapToInt((x) -> x).summaryStatistics();
- System.out.println("Highest prime number in List :" + stats.getMax());
- System.out.println("Lowest prime number in List :" + stats.getMin());
- System.out.println("Sum of all prime numbers :" + stats.getSum());
- System.out.println("Average of all prime numbers :" + stats.getAverage());
来源: http://www.jianshu.com/p/c5bbfec69f0f