lambda 表达式

简介

在我看来 lambda 表达式就是简化了以前的一大堆繁琐的操作,让我们代码看起来更加简洁,让以前五六行甚至更多行的代码只需要两三行就能解决,但是对于 Java 初学者可能不是特别友好,可能一下子理解不过来该代码想表达什么。

lambda 表达式是一段可以传递的代码,因此它可以被执行一次或多次

lambda 表达式的语法

我们先来看看老版本的排序字符串的办法,这里我们不按照字典序,而按照字符串的大小来排序

Comparator<String> comparator = new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return Integer.compare(o1.length(),o2.length());
}
};
List<String> list = Arrays.asList("aaaa", "aaa", "aa", "a", "aaaaa");
Collections.sort(list,comparator);// [a, aa, aaa, aaaa, aaaaa]

老版本的排序我们会先创建一个自定义比较器,然后按照比较器的规则进行排序。

现在我们来看看 lambda 表达式如何来实现的

List<String> list = Arrays.asList("aaaa", "aaa", "aa", "a", "aaaaa");
Collections.sort(list,(String o1,String o2)->{
return Integer.compare(o1.length(),o2.length());
});//[a, aa, aaa, aaaa, aaaaa]

可以看到,代码浓缩了不少,但是可读性没有原来好,原来需要先创建一个比较器然后将比较器传到 Collections 工具类进行排序,典型的面向对象编程,但是 lambda 表达式确是将代码传进去然后直接进行比较。如果你以为这样就是最简便的,那你就错了,有更简便的。

List<String> list = Arrays.asList("aaaa", "aaa", "aa", "a", "aaaaa");
Collections.sort(list,(String o1,String o2)
->Integer.compare(o1.length(),o2.length()));

如果返回值只有一行,可以省略大括号和 return 关键字。

List<String> list = Arrays.asList("aaaa", "aaa", "aa", "a", "aaaaa");
Collections.sort(list,(o1,o2)->Integer.compare(o1.length(),o2.length()));

如果是带泛型的容器,参数的类型可以省略,JVM 会自己进行上下文判断出类型。

我们可以看到从原来的那么多行代码浓缩成了一行,看着清爽了很多,但是可读性却没有原来那么友好了。

变量作用域

  • 访问局部变量

    可以在 lambda 表达式中访问外部的局部变量

    int number = 10;
    Converter<String,Integer> converter = num->Integer.valueOf(num + number);
    System.out.println(converter.convert("123"));//12310

    在匿名内部类中外部的局部变量必须声明为 final。而我们这里不需要。

    但是要注意的是这的 number 不能被后面的代码修改,否则编译不通过,也就是具有隐性的 final 语义。

  • 访问 字段和静态变量

    我们对 lambda 表达式中的实例字段和静态字段变量都有读写访问权限。

    class Lambda4 {
    static int outerStaticNum;
    int outerNum; void testScopes() {
    Converter<Integer, String> stringConverter1 = (from) -> {
    outerNum = 23;
    return String.valueOf(from);
    }; Converter<Integer, String> stringConverter2 = (from) -> {
    outerStaticNum = 72;
    return String.valueOf(from);
    };
    }
    }
  • 无法在 lambda 表达式中访问默认接口方法。

函数式接口

在 Java 中有许多已有的接口都选哦封装成代码块,比如 Runnable 或者 Comparator 。 lambda 表达式与这些接口是像后兼容的。

对于只包含一个抽象方法的接口,但是可以有多个非抽象方法,(非抽象方法也是 java 8 新特性,我们后面会讲到),我们可以通过 lambda 表达式来创建该接口的对象。这种接口被称为函数式接口。

Java 8 新增加了一种特殊的注解 @FunctionalInterface,该接口会自动判断你的接口中是否只有一个抽象方法,如果多于一个抽象方法就会报错。

现在我们来自定义一个函数式接口:

@FunctionalInterface
interface Converter<F,T>{
T convert(F num);
}
// 将数字形式的字符串转化成整型
Converter<String,Integer> converter = (num -> Integer.valueOf(num));
System.out.println(converter.convert("123").getClass());//class java.lang.Integer

现在来解释下该代码,在该代码中我们的函数式接口中定义了一个方法,该方法能够实现传入一个 F 类型的参数,我们可以对这个类型的参数进行各种处理,最后返回一个 T 类型的结果。在这里我只是简单的将传进来的 string 转成了 integer。这里的 F 与 T 都是泛型类型,可以为任何实体类。

java 8 帮我们实现了很多函数式接口,大部分都不需要我们自己写,这些接口在 java.util.function 包 里,可以自行进行查阅。

上面的代码可以写的更加简单:

Converter<String,Integer> converter = Integer::valueOf;
System.out.println(converter.convert("123").getClass());//class java.lang.Integer

java 8 可以通过 ** : : **来传递方法或者构造函数的引用。上面的演示了如果引用静态方法,引用对象方法也相差不大,只是需要声明一个对象:

class Demo{
public Integer demo(String num){
return Integer.valueOf(num);
}
}
public class Main {
public static void main(String[] args) {
Demo demo = new Demo();
Converter<String,Integer> converter = demo::demo;
System.out.println(converter.convert("123").getClass());
//class java.lang.Integer
}
}

内置函数式接口

  • Predicates

    Predicate 接口是只有一个参数的返回布尔类型值的 断言型 接口。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑(比如:与,或,非)

    @FunctionalInterface
    public interface Predicate<T> {
    // 该方法是接受一个传入类型,返回一个布尔值.此方法应用于判断.
    boolean test(T t);
    ....
    }
  • Functions

    Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起(compose, andThen)

    @FunctionalInterface
    public interface Function<T, R> { //将Function对象应用到输入的参数上,然后返回计算结果。
    R apply(T t);
    ...
    }
  • Suppliers

    Supplier 接口产生给定泛型类型的结果。 与 Function 接口不同,Supplier 接口不接受参数。

  • Consumers

    Consumer 接口表示要对单个输入参数执行的操作。

  • Comparators

    Comparator 是老Java中的经典接口, Java 8在此之上添加了多种默认方法

默认方法

前面已经有写地方提到了接口的默认方法,这里对其做下介绍。接口的默认方法也是 java 8 新出的功能。能够通过使用 default 关键字向接口添加非抽象方法实现。

interface Formula{

    double calculate(int a);

    default double sqrt(int a) {
return Math.sqrt(a);
} }

Formula 接口中除了抽象方法计算接口公式还定义了默认方法 sqrt。 实现该接口的类只需要实现抽象方法 calculate。 默认方法sqrt 可以直接使用。当然你也可以直接通过接口创建对象,然后实现接口中的默认方法就可以了,我们通过代码演示一下这种方式。

public class Main {
public static void main(String[] args) {
// TODO 通过匿名内部类方式访问接口
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
System.out.println(formula.calculate(100)); // 100.0
System.out.println(formula.sqrt(16)); // 4.0
}
}

formula 是作为匿名对象实现的。该代码非常容易理解,6行代码实现了计算 sqrt(a * 100)

不管是抽象类还是接口,都可以通过匿名内部类的方式访问。不能通过抽象类或者接口直接创建对象。对于上面通过匿名内部类方式访问接口,我们可以这样理解:一个内部类实现了接口里的抽象方法并且返回一个内部类对象,之后我们让接口的引用来指向这个对象。

Stream(流)

Stream 是在 java.util 下的。Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种,最终操作返回一特定类型的计算结果,而中间操作返回 Stream 本身,这样我们就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源,比如 java.util.Collection 的子类:List 或者 Set。Map 不支持。Stream 的操作可以串行执行或者并行执行。

当我们使用 Stream 时,我们将通过三个阶段来建立一个操作流水线。

  1. 创建一个 Stream。
  2. 在一个或多个步骤中,指定将初始 Stream 转换成为另一个 Stream 的中间操作。
  3. 使用一个终止操作来产生一个结果。该操作会强制它之前的延迟操作立即执行。

在这之后 stream 就不会再被使用了。

创建 stream

通过 Java 8 在 Collection 接口中新提娜佳的 stram 方法,可以将任何集合转化为一个 Stream。如果我们面对的是一个数组,也可以用静态的 Stream.of 方法将其转化为一个 Stream。

@Test
public void test1(){
List<String> stringList = new ArrayList<>();
stringList.add("ddd2");
stringList.add("aaa2");
stringList.add("bbb1");
stringList.add("aaa1");
stringList.add("bbb3");
stringList.add("ccc");
stringList.add("bbb2");
stringList.add("ddd1");
Stream<String> stream = stringList.stream();
//Stream<String> stringStream = stringList.parallelStream();
}

我们可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。

Filter(过滤)

过滤通过一个predicate接口来过滤并只保留符合条件的元素,该操作属于中间操作,所以我们可以在过滤后的结果来应用其他Stream操作。(比如forEach)。forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作,所以我们不能在forEach之后来执行其他Stream操作。

stringList
.stream()
.filter(s->s.startsWith("a"))
.forEach(System.out::println);

forEach 是为 Lambda 而设计的,保持了最紧凑的风格。而且 Lambda 表达式本身是可以重用的,非常方便。

Sorted(排序)

排序是一个中间操作,返回的是排序好的 Stream 。如果我们不指定一个自定义的 Comparator 则会使用默认排序。

stringList
.stream()
.sorted((o1,o2)->Integer.compare(o1.length(),o2.length()))
.forEach(System.out::println);

需要注意的是,排序只创建了一个排列好后的Stream,而不会影响原有的数据源,排序之后原数据stringCollection是不会被修改的。

Map(映射)

中间操作 map 会将元素根据指定的 Function 接口来依次将元素转成另外的对象。

map返回的 Stream 类型是根据我们 map 传递进去的函数的返回值决定的。

stringList
.stream()
.map(String::toUpperCase)
.sorted((o1,o2)->Integer.compare(o1.length(),o2.length()))
.forEach(System.out::println);

Match(匹配)

Stream提供了多种匹配操作,允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是 最终操作 ,并返回一个 boolean 类型的值。

boolean anyStartsWithA =
stringList
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true boolean allStartsWithA =
stringList
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false boolean noneStartsWithZ =
stringList
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true

Count(计数)

计数是一个 最终操作,返回Stream中元素的个数,返回值类型是 long

long count = stringList
.stream()
.map(String::toUpperCase)
.sorted((o1, o2) -> Integer.compare(o1.length(), o2.length()))
.count();
System.out.println(count);

Parallel Stream(并行流)

Stream有串行和并行两种,串行Stream上的操作是在一个线程中依次完成,而并行Stream则是在多个线程上同时执行。

下面使用串行流和并行流为一个大容器进行排序,比较两者性能。

串行排序

@Test
public void test1(){
int max = 1000000;
List<String> list = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
list.add(uuid.toString());
}
long startTime = System.nanoTime();
long count = list.stream().sorted().count();
System.out.println(count);
long endTime = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(endTime-startTime);
System.out.println(millis);
//1000000
//877
}

并行排序

@Test
public void test2(){
int max = 1000000;
List<String> list = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
list.add(uuid.toString());
}
long startTime = System.nanoTime();
long count = list.parallelStream().sorted().count();
System.out.println(count);
long endTime = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(endTime-startTime);
System.out.println(millis);
}
//1000000
//512

可以明显看出在大数据量的情况下并行排序比串行来的快。但是小数据量的话却是串行排序比较快,原因是并行需要涉及到上下文切换。

Collector 和 Collectors

Collector 是专门用来作为 Stream 的 collect 方法的参数的。而 Collectors 是作为生产具体 Collector 的工具类。

  • toList():将流构造成 list

    List<String> collect = list.stream().collect(Collectors.toList());
  • toSet():将流构造成set

    Set<String> set = list.stream().collect(Collectors.toSet());
    Set<String> treeSet = list.stream().collect(Collectors.toCollection(TreeSet::new));
  • joining():拼接流中所有字符串

    String collect = list.stream().collect(Collectors.joining());
    String collect = list.stream().collect(Collectors.joining(";"));
  • toMap():将流转成 map

    Map<String, String> collect = list
    .stream()
    .collect(Collectors
    .toMap(e -> "key" + e, e -> "v" + e,(a,b)->b,HashMap::new));

    上面的 e -> "key" + e 定义了 map 的 key 的生成规则,e -> "v" + e 定义了 map 的 value 的生成规则,(a,b)->b 表示冲突的解决方案,如果键 a 和 键 b 冲突了则该键键值取 b 的,HashMap::new 定义了生成的 map 为 hashmap。

Map 新方法

Map 虽然不支持 Stream 但是我们可以通过 map.keySet().stream(),map.values().stream()map.entrySet().stream() 来通过过去键、值的集合再转换成流进行处理。

Java 8 中 map 新方法:

  • putIfAbsent(key, value)//有则不加,无则加
  • map.forEach((key, value) -> System.out.println(value));//循环打印
  • map.computeIfPresent(3, (num, val) -> val + num);//当key 存在则执行后面方法
  • map.computeIfAbsent(23, num -> "val" + num);//当key 不存在时执行后面方法
  • map.getOrDefault(42, 1);//有则获取,无则置 1
  • map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
    //如果键名不存在则插入,否则则对原键对应的值做合并操作并重新插入到map中。

新的日期与时间 API

  • LocalTime(本地时间)

    LocalTime 定义了一个没有时区信息的时间

    方法 描述
    now,of 这些静态方法可以根据当前时间或指定的年、月、日来创建一个 LocalTime 对象
    getHour,getMinute,getSecond,getNano 获得当前 LocalTime 的小时、分钟、秒钟及微妙值
    isBefore,isAfter 比较两个LocalTime
  • LocalDate(本地日期)

    LocalDate 表示了一个确切的日期,比如 2014-03-11。该对象值是不可变的,用起来和LocalTime基本一致。

    方法 描述
    now,of 这些静态方法可以根据当前时间或指定的年、月、日来创建一个LocalDate对象
    getDayOfMonth 获取月份天数(在 1~ 31 之间)
    getDayOfYear 获取年份天数(在1~366之间)
    getMonth,getMonthValue 获得月份,或者为一个 Month 枚举的值,或者是 1 ~ 12 之间的一个数字
    getYear 获取年份
    isBefore,isAfter 比较两个LocalDate

上面这些方法是比较常用的,其余的可以自行查阅。

参考资料

Java 新特性总结——简单实用的更多相关文章

  1. 主流的单元测试工具之-JAVA新特性-Annotation 写作者:组长 梁伟龙

    1:什么是Annotation?Annotation,即“@xxx”(如@Before,@After,@Test(timeout=xxx),@ignore),这个单词一般是翻译成元数据,是JAVA的一 ...

  2. 主流的单元测试工具之-JAVA新特性-Annotation

    1:什么是Annotation?Annotation,即“@xxx”(如@Before,@After,@Test(timeout=xxx),@ignore),这个单词一般是翻译成元数据,是JAVA的一 ...

  3. Hi java新特性

    java新特性 1995.5.23 java语言 1996 jdk1.0 250个类在API 主要用在桌面型应用程序1997 jdk1.1 500 图形用户界面编程1998 jdk1.2 2300 J ...

  4. java新特性stream

    java新特性stream,也称为流式编程. 在学习stream之前先了解一下java内置的四大函数 第一种函数式函数,后面是lambda表达式写法 /*Function<String,Inte ...

  5. Java 新特性(5) - Java EE 5 新特性

    Java EE 5 由 Java Community Process 通过 Java Specification Request 244 发布,这个 “总纲” JSR 指出了详细描述 Java EE ...

  6. Java 新特性(3) - JDK7 新特性

    http://www.ibm.com/developerworks/cn/java/j-lo-jdk7-1/ JSR292:支持动态类型语言(InvokeDynamic) 近 年来越来越多的基于 JV ...

  7. Java 新特性(2) - JDK6 新特性

    http://freesea.iteye.com/blog/160133 JDK6的新特性之一_Desktop类和SystemTray类 JDK6的新特性之二_使用JAXB2来实现对象与XML之间的映 ...

  8. Java 新特性(7) - Java EE 7 新特性

    http://www.ibm.com/developerworks/cn/java/j-lo-javaee7/ 新特性主要集中在: 1. 提高开发人员的生产力 2. 加强对 HTML5 动态可伸缩应用 ...

  9. 【Java新特性】Lambda表达式典型案例,你想要的的都在这儿了!!

    写在前面 不得不说,有些小伙伴的学习热情真高,学完了Lambda表达式的语法,想来几个典型案例再强化下.于是问冰河能否给几个Lambda表达式的典型使用示例.于是乎,便有了这篇文章. 案例一 需求 调 ...

随机推荐

  1. 零元学Expression Blend 4 - Chapter 10 用实例了解布局容器系列-「StackPanel」

    原文:零元学Expression Blend 4 - Chapter 10 用实例了解布局容器系列-「StackPanel」 本系列将教大家以实做案例认识Blend 4 的布局容器,此章介绍的布局容器 ...

  2. C# ACCESS 查询提示“至少一个参数没有被指定”问题

    错误的SQL指令如下: sqlStr = “select * from  tb_userInfo where userName=” + userName;    //错误的 sql 指令 正确的SQL ...

  3. MinGW版Qt如何搭建lua环境?(详细步骤)

    操作系统是windows,lua是Lua for Windows 5.1.4包含了这三个头文件 <ignore_js_op>  在.pro里加了includepath: <ignor ...

  4. 地球坐标-火星坐标-百度坐标及之间的转换算法 C#

    美国GPS使用的是WGS84的坐标系统,以经纬度的形式来表示地球平面上的某一个位置.但在我国,出于国家安全考虑,国内所有导航电子地图必须使 用国家测绘局制定的加密坐标系统,即将一个真实的经纬度坐标加密 ...

  5. 海康威视频监控设备Web查看系统(二):服务器篇

    声明:本系列文章只提供交流与学习使用.文章中所有涉及到海康威视设备的SDK均可在海康威视官方网站下载得到.文章中所有除官方SDK意外的代码均可随意使用,任何涉及到海康威视公司利益的非正常使用由使用者自 ...

  6. Python之二叉树Binarytree

    二叉树是树的简化版,除根节点之外的所有节点都有一个父节点,任意节点都可以最多有一个左子节点和右子节点. 二叉树的遍历是非常重要的算法,主要分为深度优先遍历和广度优先遍历. 其中深度优先遍历按照访问根节 ...

  7. vim 列编辑模式

    vim 列编辑模式 标签: vim 视窗模式 列编辑模式 vim 列编辑模式 例子:给列批量添加前缀.后缀.修改字段 vim 列编辑模式 vim 有三种编辑模式,命令模式.输入模式.视窗模式,我们常用 ...

  8. sql server编写简洁四则运算表达式脚本实现计算批次功能(C#等其它编程语言也能直接用此通用表达式)

    问题: 在数据库编程开发中,有时会遇到数据量比较大的情况,如果直接大批量进行添加数据.修改数据.删除数据,就会是比较大的事务,事务日志也比较大,耗时久的话会对正常操作造成一定的阻塞.虽不至于达到删库跑 ...

  9. mysql数据库在linux下的导出和导入及每天的备份

    mysql数据库的导出,导入 1. 导出数据库为sql文件 mysqldump 数据库名 -uroot -p > xxx.sql 导出数据表结构和数据 eg.   mysqldump cloud ...

  10. centos安装netcat TCP UDP测试工具 简称 nc,安全界叫它瑞士军刀

    centos安装netcat 今天安装swoole后,测试UDP服务需要用到netcat,然而百度了很多安装方法,并没有一个好用的.几经尝试,终于安装成功,现在就分享给大家,以供参考. 配置环境:ce ...