Java进阶篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用详解(很详细)

前言

本篇主要讲述是java中jdk1.8的一些新语法特性使用，主要是lambda、stream和localdate日期的一些使用讲解。

lambda

lambda介绍

lambda 表达式(lambda expression)是一个匿名函数，lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。

lambda表达式的结构

• 一个 lambda 表达式可以有零个或多个参数
• 参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
• 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (string a, int b, float c)
• 空圆括号代表参数集为空。例如：() -> 42
• 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a
• lambda 表达式的主体可包含零条或多条语句
• 如果 lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
• 如果 lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

lambda 表达式的使用

下面我们先使用一个简单的例子来看看lambda的效果吧。

比如我们对map 的遍历
传统方式遍历如下:

        map<string, string> map = new hashmap<>();
        map.put("a", "a");
        map.put("b", "b");
        map.put("c", "c");
        map.put("d", "d");

        system.out.println("map普通方式遍历:");
        for (string key : map.keyset()) {
            system.out.println("k=" + key + "，v=" + map.get(key));
        }

使用lambda进行遍历:

        system.out.println("map拉姆达表达式遍历:");
        map.foreach((k, v) -> {
            system.out.println("k=" + k + "，v=" + v);
    });

list也同理，不过list还可以通过双冒号运算符遍历:

        list<string> list = new arraylist<string>();
        list.add("a");
        list.add("bb");
        list.add("ccc");
        list.add("dddd");
        system.out.println("list拉姆达表达式遍历:");
        list.foreach(v -> {
            system.out.println(v);
        });
        system.out.println("list双冒号运算符遍历:");
        list.foreach(system.out::println);

输出结果:

    map普通方式遍历:
    k=a，v=a
    k=b，v=b
    k=c，v=c
    k=d，v=d
    map拉姆达表达式遍历:
    k=a，v=a
    k=b，v=b
    k=c，v=c
    k=d，v=d
    list拉姆达表达式遍历:
    a
    bb
    ccc
    dddd
    list双冒号运算符遍历:
    a
    bb
    ccc
    dddd

lambda除了在for循环遍历中使用外，它还可以代替匿名的内部类。
比如下面这个例子的线程创建:

    //使用普通的方式创建
    runnable r1 = new runnable() {
        @override
        public void run() {
            system.out.println("普通方式创建!");
        }
    };
    
    //使用拉姆达方式创建
    runnable r2 = ()-> system.out.println("拉姆达方式创建!");

注: 这个例子中使用lambda表达式的时候，编译器会自动推断：根据线程类的构造函数签名 runnable r { }，将该 lambda 表达式赋runnable 接口。

lambda 表达式与匿名类的区别
使用匿名类与 lambda 表达式的一大区别在于关键词的使用。对于匿名类，关键词 this 解读为匿名类，而对于 lambda 表达式，关键词 this 解读为写就 lambda 的外部类。

lambda表达式使用注意事项

lambda虽然简化了代码的编写，但同时也减少了可读性。

stream

stream介绍

stream 使用一种类似用 sql 语句从数据库查询数据的直观方式来提供一种对 java 集合运算和表达的高阶抽象。stream api可以极大提高java程序员的生产力，让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

stream特性：

• 不是数据结构： 它没有内部存储，它只是用操作管道从 source（数据结构、数组、generator function、io channel）抓取数据。它也绝不修改自己所封装的底层数据结构的数据。例如 stream 的 filter 操作会产生一个不包含被过滤元素的新 stream，而不是从 source 删除那些元素。
• 不支持索引访问： 但是很容易生成数组或者 list 。
• 惰性化：很多 stream 操作是向后延迟的，一直到它弄清楚了最后需要多少数据才会开始。intermediate 操作永远是惰性化的。
• 并行能力。当一个 stream 是并行化的，就不需要再写多线程代码，所有对它的操作会自动并行进行的。
• 可以是无限的：集合有固定大小，stream 则不必。limit(n) 和 findfirst() 这类的 short-circuiting 操作可以对无限的 stream 进行运算并很快完成。
• 注意事项：所有 stream 的操作必须以 lambda 表达式为参数。

stream 流操作类型：

• intermediate：一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。 这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
• terminal：一个流只能有一个 terminal 操作，当这个操作执行后，流就被使用“光”了，无法再被操作。 所以这必定是流的最后一个操作。 terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个 side effect。

stream使用

这里我们依旧使用一个简单示例来看看吧。
在开发中，我们有时需要对一些数据进行过滤，如果是传统的方式，我们需要对这批数据进行遍历过滤，会显得比较繁琐，如果使用steam流方式的话，那么可以很方便的进行处理。

首先通过普通的方式进行过滤:

list<string> list = arrays.aslist("张三", "李四", "王五", "xuwujing");
    system.out.println("过滤之前:" + list);
    list<string> result = new arraylist<>();
    for (string str : list) {
        if (!"李四".equals(str)) {
            result.add(str);
        }
    }
    system.out.println("过滤之后:" + result);

使用steam方式进行过滤：

list<string> result2 = list.stream().filter(str -> !"李四".equals(str)).collect(collectors.tolist());
system.out.println("stream 过滤之后:" + result2);

输出结果:

过滤之前:[张三, 李四, 王五, xuwujing]
过滤之后:[张三, 王五, xuwujing]
stream 过滤之后:[张三, 王五, xuwujing]

是不是很简洁和方便呢。
其实stream流还有更多的使用方法，filter只是其中的一角而已。那么在这里我们就来学习了解下这些用法吧。

1.构造stream流的方式

    stream stream = stream.of("a", "b", "c");
    string[] strarray = new string[] { "a", "b", "c" };
    stream = stream.of(strarray);
    stream = arrays.stream(strarray);
    list<string> list = arrays.aslist(strarray);
    stream = list.stream();

2.stream流的之间的转换

注意:一个stream流只可以使用一次，这段代码为了简洁而重复使用了数次，因此会抛出 stream has already been operated upon or closed 异常。

try {
        stream<string> stream2 = stream.of("a", "b", "c");
        // 转换成 array
        string[] strarray1 = stream2.toarray(string[]::new);

        // 转换成 collection
        list<string> list1 = stream2.collect(collectors.tolist());
        list<string> list2 = stream2.collect(collectors.tocollection(arraylist::new));          
        set set1 = stream2.collect(collectors.toset());
        stack stack1 = stream2.collect(collectors.tocollection(stack::new));

        // 转换成 string
        string str = stream.collect(collectors.joining()).tostring();
    } catch (exception e) {
        e.printstacktrace();
    }

3.stream流的map使用

map方法用于映射每个元素到对应的结果，一对一。

示例一：转换大写

    list<string> list3 = arrays.aslist("zhangsan", "lisi", "wangwu");
    system.out.println("转换之前的数据:" + list3);
    list<string> list4 = list3.stream().map(string::touppercase).collect(collectors.tolist());
    system.out.println("转换之后的数据:" + list4); 
    // 转换之后的数据:[zhangsan, lisi,wangwu]

示例二：转换数据类型

    list<string> list31 = arrays.aslist("1", "2", "3");
    system.out.println("转换之前的数据:" + list31);
    list<integer> list41 = list31.stream().map(integer::valueof).collect(collectors.tolist());
    system.out.println("转换之后的数据:" + list41); 
    // [1, 2, 3]

示例三：获取平方

    list<integer> list5 = arrays.aslist(new integer[] { 1, 2, 3, 4, 5 });
    list<integer> list6 = list5.stream().map(n -> n * n).collect(collectors.tolist());
    system.out.println("平方的数据:" + list6);
    // [1, 4, 9, 16, 25]

4.stream流的filter使用

filter方法用于通过设置的条件过滤出元素。

示例二：通过与 findany 得到 if/else 的值

list<string> list = arrays.aslist("张三", "李四", "王五", "xuwujing");
string result3 = list.stream().filter(str -> "李四".equals(str)).findany().orelse("找不到!");
string result4 = list.stream().filter(str -> "李二".equals(str)).findany().orelse("找不到!");

system.out.println("stream 过滤之后 2:" + result3);
system.out.println("stream 过滤之后 3:" + result4);
//stream 过滤之后 2:李四
//stream 过滤之后 3:找不到!

示例三：通过与 maptoint 计算和

    list<user> lists = new arraylist<user>();
    lists.add(new user(6, "张三"));
    lists.add(new user(2, "李四"));
    lists.add(new user(3, "王五"));
    lists.add(new user(1, "张三"));
    // 计算这个list中出现 "张三" id的值
    int sum = lists.stream().filter(u -> "张三".equals(u.getname())).maptoint(u -> u.getid()).sum();

    system.out.println("计算结果:" + sum); 
    // 7

5.stream流的flatmap使用

flatmap 方法用于映射每个元素到对应的结果，一对多。

示例:从句子中得到单词

    string worlds = "the way of the future";
    list<string> list7 = new arraylist<>();
    list7.add(worlds);
    list<string> list8 = list7.stream().flatmap(str -> stream.of(str.split(" ")))
            .filter(world -> world.length() > 0).collect(collectors.tolist());
    system.out.println("单词:");
    list8.foreach(system.out::println);
    // 单词:
    // the 
    // way 
    // of 
    // the 
    // future

6.stream流的limit使用

limit 方法用于获取指定数量的流。

示例一：获取前n条数的数据

    random rd = new random();
    system.out.println("取到的前三条数据:");
    rd.ints().limit(3).foreach(system.out::println);
    //  取到的前三条数据:
    //  1167267754
    //  -1164558977
    //  1977868798

示例二：结合skip使用得到需要的数据

skip表示的是扔掉前n个元素。

list<user> list9 = new arraylist<user>();
    for (int i = 1; i < 4; i++) {
        user user = new user(i, "pancm" + i);
        list9.add(user);
    }
    system.out.println("截取之前的数据:");
    // 取前3条数据，但是扔掉了前面的2条，可以理解为拿到的数据为 2<=i<3 (i 是数值下标)
    list<string> list10 = list9.stream().map(user::getname).limit(3).skip(2).collect(collectors.tolist());
    system.out.println("截取之后的数据:" + list10);
    //      截取之前的数据:
    //      姓名:pancm1
    //      姓名:pancm2
    //      姓名:pancm3
    //      截取之后的数据:[pancm3]

注:user实体类中 getname 方法会打印姓名。

7.stream流的sort使用

sorted方法用于对流进行升序排序。

示例一：随机取值排序

    random rd2 = new random();
    system.out.println("取到的前三条数据然后进行排序:");
    rd2.ints().limit(3).sorted().foreach(system.out::println);
    //  取到的前三条数据然后进行排序:
    //  -2043456377
    //  -1778595703
    //  1013369565

示例二：优化排序

tips:先获取在排序效率会更高!

    //普通的排序取值
    list<user> list11 = list9.stream().sorted((u1, u2) -> u1.getname().compareto(u2.getname())).limit(3)
            .collect(collectors.tolist());
    system.out.println("排序之后的数据:" + list11);
    //优化排序取值
    list<user> list12 = list9.stream().limit(3).sorted((u1, u2) -> u1.getname().compareto(u2.getname()))
            .collect(collectors.tolist());
    system.out.println("优化排序之后的数据:" + list12);
    //排序之后的数据:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]
    //优化排序之后的数据:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]
    

8.stream流的peek使用

peek对每个元素执行操作并返回一个新的stream

示例:双重操作

    system.out.println("peek使用:");
    stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> system.out.println("转换之前: " + e))
            .map(string::touppercase).peek(e -> system.out.println("转换之后: " + e)).collect(collectors.tolist());
    
    //  转换之前: three
    //  转换之后: three
    //  转换之前: four
    //  转换之后: four

9.stream流的parallel使用

parallelstream 是流并行处理程序的代替方法。

示例:获取空字符串的数量

    list<string> strings = arrays.aslist("a", "", "c", "", "e","", " ");
    // 获取空字符串的数量
    long count =  strings.parallelstream().filter(string -> string.isempty()).count();
    system.out.println("空字符串的个数:"+count);

10.stream流的max/min/distinct使用

示例一：得到最大最小值

    list<string> list13 = arrays.aslist("zhangsan","lisi","wangwu","xuwujing");
    int maxlines = list13.stream().maptoint(string::length).max().getasint();
    int minlines = list13.stream().maptoint(string::length).min().getasint();
    system.out.println("最长字符的长度:" + maxlines+",最短字符的长度:"+minlines);
    //最长字符的长度:8,最短字符的长度:4

示例二：得到去重之后的数据

    string lines = "good good study day day up";
    list<string> list14 = new arraylist<string>();
    list14.add(lines);
    list<string> words = list14.stream().flatmap(line -> stream.of(line.split(" "))).filter(word -> word.length() > 0)
            .map(string::tolowercase).distinct().sorted().collect(collectors.tolist());
    system.out.println("去重复之后:" + words);
    //去重复之后:[day, good, study, up]

11.stream流的match使用

• allmatch：stream 中全部元素符合则返回 true ;
• anymatch：stream 中只要有一个元素符合则返回 true;
• nonematch：stream 中没有一个元素符合则返回 true。

示例:数据是否符合

    boolean all = lists.stream().allmatch(u -> u.getid() > 3);
    system.out.println("是否都大于3:" + all);
    boolean any = lists.stream().anymatch(u -> u.getid() > 3);
    system.out.println("是否有一个大于3:" + any);
    boolean none = lists.stream().nonematch(u -> u.getid() > 3);
    system.out.println("是否没有一个大于3的:" + none);       
    //  是否都大于3:false
    //  是否有一个大于3:true
    //  是否没有一个大于3的:false

12.stream流的reduce使用

reduce 主要作用是把 stream 元素组合起来进行操作。

示例一：字符串连接

string concat = stream.of("a", "b", "c", "d").reduce("", string::concat);
system.out.println("字符串拼接:" + concat);

示例二：得到最小值

    double minvalue = stream.of(-4.0, 1.0, 3.0, -2.0).reduce(double.max_value, double::min);
    system.out.println("最小值:" + minvalue);
    //最小值:-4.0

示例三：求和

    // 求和, 无起始值
    int sumvalue = stream.of(1, 2, 3, 4).reduce(integer::sum).get();
    system.out.println("有无起始值求和:" + sumvalue);
    // 求和, 有起始值
     sumvalue = stream.of(1, 2, 3, 4).reduce(1, integer::sum);
     system.out.println("有起始值求和:" + sumvalue);
    //  有无起始值求和:10
    //  有起始值求和:11

示例四：过滤拼接

concat = stream.of("a", "b", "c", "d", "e", "f").filter(x -> x.compareto("z") > 0).reduce("", string::concat);
system.out.println("过滤和字符串连接:" + concat);
    //过滤和字符串连接:ace
    

13.stream流的iterate使用

iterate 跟 reduce 操作很像，接受一个种子值，和一个unaryoperator（例如 f）。 然后种子值成为 stream 的第一个元素，f(seed) 为第二个，f(f(seed)) 第三个，以此类推。 在 iterate 时候管道必须有 limit 这样的操作来限制 stream 大小。

示例:生成一个等差队列

    system.out.println("从2开始生成一个等差队列:");
    stream.iterate(2, n -> n + 2).limit(5).foreach(x -> system.out.print(x + " "));
    // 从2开始生成一个等差队列:
    // 2 4 6 8 10

14.stream流的supplier使用

通过实现supplier类的方法可以自定义流计算规则。

示例：随机获取两条用户信息

    system.out.println("自定义一个流进行计算输出:");
    stream.generate(new usersupplier()).limit(2).foreach(u -> system.out.println(u.getid() + ", " + u.getname()));
    
    //第一次:
    //自定义一个流进行计算输出:
    //10, pancm7
    //11, pancm6
    
    //第二次:
    //自定义一个流进行计算输出:
    //10, pancm4
    //11, pancm2
    
    //第三次:
    //自定义一个流进行计算输出:
    //10, pancm4
    //11, pancm8


class usersupplier implements supplier<user> {
    private int index = 10;
    private random random = new random();

    @override
    public user get() {
        return new user(index++, "pancm" + random.nextint(10));
    }
}

15.stream流的groupingby/partitioningby使用

• groupingby：分组排序；
• partitioningby：分区排序。

示例一：分组排序

    system.out.println("通过id进行分组排序:");
    map<integer, list<user>> persongroups = stream.generate(new usersupplier2()).limit(5)
            .collect(collectors.groupingby(user::getid));
    iterator it = persongroups.entryset().iterator();
    while (it.hasnext()) {
        map.entry<integer, list<user>> persons = (map.entry) it.next();
        system.out.println("id " + persons.getkey() + " = " + persons.getvalue());
    }
    
    //  通过id进行分组排序:
    //  id 10 = [{"id":10,"name":"pancm1"}] 
    //  id 11 = [{"id":11,"name":"pancm3"}, {"id":11,"name":"pancm6"}, {"id":11,"name":"pancm4"}, {"id":11,"name":"pancm7"}]



    class usersupplier2 implements supplier<user> {
        private int index = 10;
        private random random = new random();
    
        @override
        public user get() {
            return new user(index % 2 == 0 ? index++ : index, "pancm" + random.nextint(10));
        }
    }

示例二：分区排序

    system.out.println("通过年龄进行分区排序:");
    map<boolean, list<user>> children = stream.generate(new usersupplier3()).limit(5)
            .collect(collectors.partitioningby(p -> p.getid() < 18));

    system.out.println("小孩: " + children.get(true));
    system.out.println("成年人: " + children.get(false));
    
    // 通过年龄进行分区排序:
    // 小孩: [{"id":16,"name":"pancm7"}, {"id":17,"name":"pancm2"}]
    // 成年人: [{"id":18,"name":"pancm4"}, {"id":19,"name":"pancm9"}, {"id":20,"name":"pancm6"}]

     class usersupplier3 implements supplier<user> {
        private int index = 16;
        private random random = new random();
    
        @override
        public user get() {
            return new user(index++, "pancm" + random.nextint(10));
        }
    }

16.stream流的summarystatistics使用

intsummarystatistics 用于收集统计信息(如count、min、max、sum和average)的状态对象。

示例:得到最大、最小、之和以及平均数。

    list<integer> numbers = arrays.aslist(1, 5, 7, 3, 9);
    intsummarystatistics stats = numbers.stream().maptoint((x) -> x).summarystatistics();
     
    system.out.println("列表中最大的数 : " + stats.getmax());
    system.out.println("列表中最小的数 : " + stats.getmin());
    system.out.println("所有数之和 : " + stats.getsum());
    system.out.println("平均数 : " + stats.getaverage());
    
    //  列表中最大的数 : 9
    //  列表中最小的数 : 1
    //  所有数之和 : 25
    //  平均数 : 5.0

stream 介绍就到这里了，jdk1.8中的stream流其实还有很多很多用法，更多的用法则需要大家去查看jdk1.8的api文档了。

localdatetime

介绍

jdk1.8除了新增了lambda表达式、stream流之外，它还新增了全新的日期时间api。在jdk1.8之前，java处理日期、日历和时间的方式一直为社区所诟病，将 java.util.date设定为可变类型，以及simpledateformat的非线程安全使其应用非常受限。因此推出了java.time包，该包下的所有类都是不可变类型而且线程安全。

关键类

• instant：瞬时时间。
• localdate：本地日期，不包含具体时间, 格式 yyyy-mm-dd。
• localtime：本地时间，不包含日期. 格式 yyyy-mm-dd hh:mm:ss.sss 。
• localdatetime：组合了日期和时间，但不包含时差和时区信息。
• zoneddatetime：最完整的日期时间，包含时区和相对utc或格林威治的时差。

使用

1.获取当前的日期时间

通过静态工厂方法now()来获取当前时间。

    //本地日期,不包括时分秒
    localdate nowdate = localdate.now();
    //本地日期,包括时分秒
    localdatetime nowdatetime = localdatetime.now();
    system.out.println("当前时间:"+nowdate);
    system.out.println("当前时间:"+nowdatetime);
    //  当前时间:2018-12-19
    //  当前时间:2018-12-19t15:24:35.822

2.获取当前的年月日时分秒

获取时间之后，直接get获取年月日时分秒。

     //获取当前的时间，包括毫秒
     localdatetime ldt = localdatetime.now();
     system.out.println("当前年:"+ldt.getyear());   //2018
     system.out.println("当前年份天数:"+ldt.getdayofyear());//172 
     system.out.println("当前月:"+ldt.getmonthvalue());
     system.out.println("当前时:"+ldt.gethour());
     system.out.println("当前分:"+ldt.getminute());
     system.out.println("当前时间:"+ldt.tostring());
    //       当前年:2018
    //       当前年份天数:353
    //       当前月:12
    //       当前时:15
    //       当前分:24
    //       当前时间:2018-12-19t15:24:35.833

3.格式化时间

格式时间格式需要用到datetimeformatter类。

localdatetime ldt = localdatetime.now();
system.out.println("格式化时间: "+ ldt.format(datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss.sss")));
//格式化时间:2018-12-19 15:37:47.119
     

4.时间增减

在指定的时间进行增加/减少年月日时分秒。

     localdatetime ldt = localdatetime.now();
     system.out.println("后5天时间:"+ldt.plusdays(5));
     system.out.println("前5天时间并格式化:"+ldt.minusdays(5).format(datetimeformatter.ofpattern("yyyy-mm-dd"))); //2018-06-16
     system.out.println("前一个月的时间:"+ldt2.minusmonths(1).format(datetimeformatter.ofpattern("yyyymm"))); //2018-06-16
     system.out.println("后一个月的时间:"+ldt2.plusmonths(1)); //2018-06-16
     system.out.println("指定2099年的当前时间:"+ldt.withyear(2099)); //2099-06-21t15:07:39.506
    //      后5天时间:2018-12-24t15:50:37.508
    //      前5天时间并格式化:2018-12-14
    //      前一个月的时间:201712
    //      后一个月的时间:2018-02-04t09:19:29.499
    //      指定2099年的当前时间:2099-12-19t15:50:37.508

5.创建指定时间

通过指定年月日来创建。

    localdate ld3=localdate.of(2017, month.november, 17);
    localdate ld4=localdate.of(2018, 02, 11);

6.时间相差比较

比较相差的年月日时分秒。

示例一: 具体相差的年月日

    localdate ld=localdate.parse("2017-11-17");
    localdate ld2=localdate.parse("2018-01-05");
    period p=period.between(ld, ld2);
    system.out.println("相差年: "+p.getyears()+" 相差月 :"+p.getmonths() +" 相差天:"+p.getdays());
    // 相差年: 0 相差月 :1 相差天:19

注:这里的月份是不满足一年，天数是不满足一个月的。这里实际相差的是1月19天，也就是49天。

示例二：相差总数的时间

chronounit 日期周期单位的标准集合。

        localdate startdate = localdate.of(2017, 11, 17);
        localdate enddate = localdate.of(2018, 01, 05);
        system.out.println("相差月份:"+chronounit.months.between(startdate, enddate));
        system.out.println("两月之间的相差的天数   : " + chronounit.days.between(startdate, enddate));
        //         相差月份:1
        //         两天之间的差在天数   : 49

注:chronounit也可以计算相差时分秒。

示例三：精度时间相差

duration 这个类以秒和纳秒为单位建模时间的数量或数量。

    instant inst1 = instant.now();
    system.out.println("当前时间戳 : " + inst1);
    instant inst2 = inst1.plus(duration.ofseconds(10));
    system.out.println("增加之后的时间 : " + inst2);
    system.out.println("相差毫秒 : " + duration.between(inst1, inst2).tomillis());
    system.out.println("相毫秒 : " + duration.between(inst1, inst2).getseconds());
    //  当前时间戳 : 2018-12-19t08:14:21.675z
    //  增加之后的时间 : 2018-12-19t08:14:31.675z
    //  相差毫秒 : 10000
    //  相毫秒 : 10

示例四：时间大小比较

     localdatetime ldt4 = localdatetime.now();
     localdatetime ldt5 = ldt4.plusminutes(10);
     system.out.println("当前时间是否大于:"+ldt4.isafter(ldt5));
     system.out.println("当前时间是否小于"+ldt4.isbefore(ldt5));
     // false
     // true

7.时区时间计算

得到其他时区的时间。

示例一:通过clock时钟类获取计算

clock时钟类用于获取当时的时间戳，或当前时区下的日期时间信息。

     clock clock = clock.systemutc();
     system.out.println("当前时间戳 : " + clock.millis());
     clock clock2 = clock.system(zoneid.of("asia/shanghai"));
     system.out.println("亚洲上海此时的时间戳:"+clock2.millis());
     clock clock3 = clock.system(zoneid.of("america/new_york"));
     system.out.println("美国纽约此时的时间戳:"+clock3.millis());
     //  当前时间戳 : 1545209277657
     //  亚洲上海此时的时间戳:1545209277657
     //  美国纽约此时的时间戳:1545209277658

示例二:通过zoneddatetime类和zoneid

     zoneid zoneid= zoneid.of("america/new_york");
     zoneddatetime datetime=zoneddatetime.now(zoneid);
     system.out.println("美国纽约此时的时间 : " + datetime.format(datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss.sss")));
     system.out.println("美国纽约此时的时间 和时区: " + datetime);
     //  美国纽约此时的时间 : 2018-12-19 03:52:22.494
     // 美国纽约此时的时间 和时区: 2018-12-19t03:52:22.494-05:00[america/new_york]

java 8日期时间api总结:

• 提供了javax.time.zoneid 获取时区。
• 提供了localdate和localtime类。
• java 8 的所有日期和时间api都是不可变类并且线程安全，而现有的date和calendar api中的java.util.date和simpledateformat是非线程安全的。
• 主包是 java.time,包含了表示日期、时间、时间间隔的一些类。里面有两个子包java.time.format用于格式化， java.time.temporal用于更底层的操作。
• 时区代表了地球上某个区域内普遍使用的标准时间。每个时区都有一个代号，格式通常由区域/城市构成（asia/tokyo），在加上与格林威治或 utc的时差。例如：东京的时差是+09:00。
• offsetdatetime类实际上组合了localdatetime类和zoneoffset类。用来表示包含和格林威治或utc时差的完整日期（年、月、日）和时间（时、分、秒、纳秒）信息。
• datetimeformatter 类用来格式化和解析时间。与simpledateformat不同，这个类不可变并且线程安全，需要时可以给静态常量赋值。 datetimeformatter类提供了大量的内置格式化工具，同时也允许你自定义。在转换方面也提供了parse()将字符串解析成日期，如果解析出错会抛出datetimeparseexception。datetimeformatter类同时还有format()用来格式化日期，如果出错会抛出datetimeexception异常。
• 再补充一点，日期格式“mmm d yyyy”和“mmm dd yyyy”有一些微妙的不同，第一个格式可以解析“jan 2 2014”和“jan 14 2014”，而第二个在解析“jan 2 2014”就会抛异常，因为第二个格式里要求日必须是两位的。如果想修正，你必须在日期只有个位数时在前面补零，就是说“jan 2 2014”应该写成 “jan 02 2014”。

其它

参考:
http://blog.oneapm.com/apm-tech/226.html
https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
http://www.importnew.com/15637.html

音乐推荐

分享一首非常带感的电音！你若想做，那么就去做吧！

项目的代码

是本人在学习java过程中记录的一些代码，也包括之前博文中使用的代码。如果感觉不错，希望顺手给个start，当然如果有不足，也希望提出。
github地址: https://github.com/xuwujing/java-study

原创不易，如果感觉不错，希望给个推荐！您的支持是我写作的最大动力！
版权声明:
作者：虚无境
博客园出处：http://www.cnblogs.com/xuwujing
csdn出处：http://blog.csdn.net/qazwsxpcm　
个人博客出处：http://www.panchengming.com

如对本文有疑问， 点击进行留言回复！！