JDK8 的 Lambda、Stream、LocalDate的使用总结

意田天

墨衍会员 · AI 创作全网分发码龄7年

关注

转载最新推荐文章于 2026-05-27 09:19:47 发布 1.3w 阅读 AI 写同款· GEO 优化 ›

JAVA8新特性（Stream API，LocalDate，LocalDateTime）【代码】JAVA8新特性（Stream API，LocalDate，LocalDateTime）阅读详情

Lambda、Stream、LocalDate的使用总结

一、Lambda

1.1 Lambda 介绍

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

1.2 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 表达式的主体包含一条以上语句，则表达式必须包含在花括号 {} 中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空、

1.3 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 表达式与匿名类的区别
使用匿名类与 Lambda 表达式的一大区别在于关键词的使用。对于匿名类，关键词 this 解读为匿名类，
而对于 Lambda 表达式，关键词 this 解读为写就 Lambda 的外部类。

### 1.4 Lambda 表达式使用注意事项
Lambda 虽然简化了代码的编写，但同时也减少了可读性。

2. Stream

2.1 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。

2.2 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

17集合间的相互转化

1. list转map

public class StreamTest {
    public static void main(String[] args) {
        List<User> commonUserList = getCommonList();
        List<User> repetitionList = getRepetitionList();
        //不重复的list集合
        Map<String, String> idAndNameMap = commonUserList.stream().collect(Collectors.toMap(User::getId, User::getName));
        System.out.println("没有重复数据的list转成的map: "+idAndNameMap);
        //有重复数据的list集合
        Map<String, String> idAndNameMap2 = repetitionList.stream().collect(Collectors.toMap(User::getId, User::getName,(k1, k2) -> k1));
        System.out.println("有重复数据的list转成的map: "+idAndNameMap2);

    }
    public static List<User> getCommonList() {
        return Lists.newArrayList(
                new User().setId("A").setName("张三"),
                new User().setId("B").setName("李四"),
                new User().setId("C").setName("王五")
        );
    }
    public static List<User> getRepetitionList() {
        return Lists.newArrayList(
                new User().setId("A").setName("张三"),
                new User().setId("A").setName("李四"),
                new User().setId("C").setName("王五")
        );
    }
}

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”。

收录于