Java8 新特性指導手冊

java8有很多新的特性，這些特性給coding帶來了很多便利。接下來會介紹一下java8的新特性使用。

// 1、lambda表達式
      

public void test0() {
    List<String> list = Arrays.asList("a", "bg", "cc");

    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String s, String t1) {
            return s.compareTo(t1);
        }
    });

    // lambda 表達式
    list.sort((o1, o2) -> o1.compareTo(o2));
}      

// 2、函數式接口
// 定義接口
@FunctionalInterface
interface Converter<T, F> {
    T convert(F f);
}

// 使用
public void test1() {
    Converter<String, Integer> converter = String::valueOf;
    System.out.println(converter.convert(28834));
}      

// 3、内置函數式接口
public void test2() {

    // Predicate是一個接口，在這裡直接對其做了實作
    Predicate<String> predicate = (s) -> s.length() > 0;
    predicate.test("foo");              // true

    // Function 函數式接口的作用是，為其提供一個原料，生産一個最終的産品
    Function<String, Integer> toInteger = Integer::valueOf;
    toInteger.apply("123");

    // Supplier 與 Function 不同，不接受入參，直接為生産一個指定的結果
    Supplier<String> supplier = String::new;
    supplier.get();

    // 對于Consumer，需要提供入參，用來被消費
    Consumer<BigDecimal> consumer = (s) -> s.toString();
    consumer.accept(new BigDecimal("100"));
}      

// 4、Optional 它不是一個函數式接口，設計它的目的是為了防止空指針異常
public void test3() {
    Optional<String> optional = Optional.of("hdfjf");
    optional.orElse("fail");
    optional.get();
    optional.ifPresent(System.out::println);
    optional.orElseThrow(RuntimeException::new);
}

// 5、Stream 流
public void test4() {

    // Filter 過濾
    // Sorted 排序
    // Map 轉換
    // Match 比對
    // Count 計數

    List<String> list = Arrays.asList("a", "bg", "cc");
    list.stream().filter(s -> s.startsWith("s"))
            .sorted()
            .map(s -> s + "1")
            .anyMatch((s) -> s.length() > 0);

    // reduce通過入參的 Function将 list 歸約成一個值
    list.stream().reduce((s1, s2) -> s1 + "#" + s2);


    // Parallel-Streams 并行流,通過多線程來處理的，能夠充分利用實體機 多核 CPU 的優勢
    list.parallelStream().sorted();
}

// 6、 map 集合，JDK 8 中對map提供了一些其他新特性
public void test5() {

    Map<Integer, String> map = new HashMap<>();
    map.putIfAbsent(1, "i");

    // computeIfPresent(), 當 key 存在時，才會做相關處理key和value
    map.computeIfPresent(3, (num, val) -> val + num);
    map.get(3);

    // 先判斷 key 為 9 的元素是否存在，存在，則做删除操作
    map.computeIfPresent(1, (num, val) -> null);
    map.containsKey(1);     // false

    // computeIfAbsent(), 當 key 不存在時，才會做相關處理
    map.computeIfAbsent(23, num -> "val" + num);
    map.containsKey(23);    // true

}

// 7、新版日期處理 Clock
public void test6() {

    Clock clock = Clock.systemDefaultZone();
    long millis = clock.millis();

    // 老版本 java.util.Date
    Instant instant = clock.instant();
    Date legacyDate = Date.from(instant);


    // Timezone時區
    ZoneId zone1 = ZoneId.of("Europe/Berlin");
    ZoneId zone2 = ZoneId.of("Brazil/East");

    // Localtime
    LocalTime now1 = LocalTime.now(zone1);
    LocalTime now2 = LocalTime.now(zone2);

    // LocalDate
    LocalDate today = LocalDate.now();
    LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
    LocalDate yesterday = tomorrow.minusDays(2);

    LocalDate independenceDay = LocalDate.of(2019, Month.FEBRUARY, 4);
    DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
}      

// 8、注解可重複
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();// 定義一個屬性值
}

// 老闆需要定義一個注解容器，才允許在同一個方法上重複使用注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotationContainer {
    MyAnnotation[] value();
}

@MyAnnotationContainer({@MyAnnotation("he"), @MyAnnotation("hh")})
public void test8() {

}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotationContainer1 {
    MyAnnotation1[] value();
}

@Target(ElementType.METHOD) // 使用範圍在類、接口和枚舉
@Retention(RetentionPolicy.RUNTIME) // 生命周期在運作時期，可以進行反射操作
@Repeatable(MyAnnotationContainer1.class) // 重複注解，需要指定注解容器
public @interface MyAnnotation1 {
    String value();// 定義一個屬性值
}