Java進階篇之十五 ----- JDK1.8的Lambda、Stream和日期的使用詳解(很詳細)

来源:https://www.cnblogs.com/xuwujing/archive/2018/12/19/10145691.html
-Advertisement-
Play Games

前言 本篇主要講述是Java中JDK1.8的一些新語法特性使用,主要是Lambda、Stream和LocalDate日期的一些使用講解。 Lambda Lambda介紹 Lambda 表達式(lambda expression)是一個匿名函數,Lambda表達式基於數學中的λ演算得名,直接對應於其中 ...


前言

本篇主要講述是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-study是本人在學習Java過程中記錄的一些代碼,也包括之前博文中使用的代碼。如果感覺不錯,希望順手給個start,當然如果有不足,也希望提出。
github地址: https://github.com/xuwujing/java-study

原創不易,如果感覺不錯,希望給個推薦!您的支持是我寫作的最大動力!
版權聲明:
作者:虛無境
博客園出處:http://www.cnblogs.com/xuwujing
CSDN出處:http://blog.csdn.net/qazwsxpcm 
個人博客出處:http://www.panchengming.com


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 初次翻譯,部分內容並非按字面翻譯,是按本人理解進行了內容重組。如有錯誤望指正。 Dart是完全的面向對象的語言,甚至函數也是一個Function類型的對象。這意味著函數可以賦值給變數或者作為函數的參數。你可以直接用變數名(其實現了Function類)作為函數名直接調用。 參考如下示例代碼: 下麵是一 ...
  • 類與類之間的關係 在我們的世界中事物和事物之間總會有一些聯繫. 在面向對象中. 類和類之間也可以產生相關的關係 1. 依賴關係 執行某個動作的時候. 需要xxx來幫助你完成這個操作. 此時的關係是最輕的. 隨時可以更換另外一個東西來完成此操作 2. 關聯關係 在對象裡面埋對象 self.girlFr ...
  • 類與類之間的關係 在我們的世界中事物和事物之間總會有一些聯繫. 在面向對象中. 類和類之間也可以產生相關的關係 1. 依賴關係 執行某個動作的時候. 需要xxx來幫助你完成這個操作. 此時的關係是最輕的. 隨時可以更換另外一個東西來完成此操作 2. 關聯關係 在對象裡面埋對象 self.girlFr ...
  • 1.自動裝箱和自動拆箱 裝箱就是自動將基本數據類型轉換為包裝器類型; (1)Integer it = 200; 實際上是:Integer it3 = Integer.valueOf(100); 自動裝箱功能:把int類型自動裝載到Integer中 先裝箱,再賦值 拆箱就是 自動將包裝器類型轉換為基本 ...
  • 當項目使用分散式架構時,就會有可能出現客戶端數據重覆提交的情況 比如,當你向伺服器發起一個借貸命令時,如果手速夠快,可能會向後臺的兩個撥款伺服器發起同一個請求 此時, 如果不進行處理, 後臺可能會向用戶撥款兩次, 但是用戶只有一次的借錢記錄. 這時, 也是用到了常用sso登錄時的技術Redis, 前 ...
  • 這一節主要講解了C語言里變數在記憶體中的位置,各種變數的使用區別,以及如何在堆棧中分配空間等C語言記憶體管理問題。 自動變數與靜態變數 auto自動變數 auto是預設的關鍵字,如實際中int a,實際為auto int a,{}內部的都是auto變數,不用為此類變數申請或者釋放空間,它都是自動完成的。 ...
  • 本節內容主要介紹了C語言程式的基本數據類型。介紹了基本類型的整數類型和浮點類型,以及簡單的講解了void類型。整數類型又包括int型、char型、bool型,浮點類型又包括單精度浮點數(float)和雙精度浮點數(double)。 ...
  • Python學習心得——模塊的導入 在Python語言的編輯器里,除了預設的內置函數外,其他函數的調用,必須先通過import語句將其導入才能使用。 import語句導入整個函數模塊 導入方法: import 函數模塊名 示例 新建一個名為 func_test.py 的文件,內容為: 保存並退出,在 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發(一):使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說,近來想嘗試開發一款安卓APP,考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP,畢竟是使用Visual Studio開發工具,使用起來也比較的順手,結合微軟官方的教程進行了安卓 ...
  • 前言 QuestPDF 是一個開源 .NET 庫,用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫,它徹底改變了我們生成 PDF 文檔的方 ...
  • 項目地址 項目後端地址: https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址: ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址: http://tree ...
  • 話不多說,直接開乾 一.下載 1.官方鏈接下載: https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe,運行開始下載SQL server; 二. ...
  • 前言 隨著物聯網(IoT)技術的迅猛發展,MQTT(消息隊列遙測傳輸)協議憑藉其輕量級和高效性,已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫,為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog支持多種接收器用於日誌存儲,增強器用於添加屬性,LogContext管理動態屬性,支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項,適用於不同需求。 ...
  • 目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據,爬取信息時需要模擬瀏覽器行為,否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下: 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • 1.前言 什麼是熱更新 游戲或者軟體更新時,無需重新下載客戶端進行安裝,而是在應用程式啟動的情況下,在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR,Xlua,ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles,Addressable, ...
  • 本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺,其實像阿裡雲,騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後,它會送 ...
  • 通過以下方式可以高效,並保證數據同步的可靠性 1.API設計 使用RESTful設計,確保API端點明確,並使用適當的HTTP方法(如POST用於創建,PUT用於更新)。 設計清晰的請求和響應模型,以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證,確保接收到的數據符合預期格 ...