Java8放棄系列之-1.1-介紹

#推薦、參考資料 參考資料：Java 8 簡明教程

中文API：中文API

JAVA8 十大新特性詳解：JAVA8 十大新特性詳解

Java8的新特性以及用法簡介:Java8的新特性以及用法簡介

#扯淡

java8相對之前的版本應該說是一個重要的版本：看過一個笑話，大概是--》 今天CTO推薦了一個10年編程經驗的大牛來公司面試。正好主程在開會，因而叫了一個應屆生去面試，本想就走個流程，可是沒想到，最後這個大牛被拒了。主程問這位應屆生，怎麼回事。應屆生不屑的說，一問三不知，Lambda，Stream都沒據說過。

#新特性

##一、Lambda表達式和函數式接口

由逗號分隔的參數列表、->符號和語句塊組成

public static void main(String[] args) {
        List<String> list = Arrays.asList("3", "1", "2");
        //循環輸出
        list.forEach(e -> System.out.println(e));


        //排序
        list.sort((e1, e2) -> {
            int r = e1.compareTo(e2);
            return r;
        });
        list.forEach(e -> System.out.println(e));
        
    }

函數接口指的是隻有一個函數的接口，這樣的接口能夠隱式轉換爲Lambda表達式。java.lang.Runnable和java.util.concurrent.Callable是函數式接口的最佳例子。

顯式說明某個接口是函數式接口，Java 8 提供了一個特殊的註解@FunctionalInterface（Java 庫中的全部相關接口都已經帶有這個註解了），舉個簡單的函數式接口的定義：

@FunctionalInterface
public interface FunctionalDefaultMethods {
    void method();

    default void defaultMethod() {            
    }        
}

默認方法和靜態方法不會破壞函數式接口的定義，所以以下的代碼是合法的。

@FunctionalInterface
public interface FunctionalDefaultMethods {
    void method();

    default void defaultMethod() {            
    }        
}

##二、接口的默認方法、靜態方法

Java 8使用兩個新概念擴展了接口的含義：默認方法和靜態方法。

默認方法：往現存接口中添加新的方法，即不強制那些實現了該接口的類也同時實現這個新加的方法。 默認方法和抽象方法之間的區別在於抽象方法須要實現，而默認方法不須要。接口提供的默認方法會被接口的實現類繼承或者覆寫。使用關鍵字default定義 如

private interface Defaulable {
    // Interfaces now allow default methods, the implementer may or 
    // may not implement (override) them.
    default String notRequired() { 
        return "Default implementation"; 
    }        
}

靜態方法：使用關鍵字static 定義 如

private interface DefaulableFactory {
  
    static Defaulable create( Supplier< Defaulable > supplier ) {
        return supplier.get();
    }
    
}

##三、方法引用

在學習lambda表達式以後，咱們一般使用lambda表達式來建立匿名方法。然而，有時候咱們僅僅是調用了一個已存在的方法。以下:

Arrays.sort(stringsArray,(s1,s2)->s1.compareToIgnoreCase(s2));

在Java8中，咱們能夠直接經過方法引用來簡寫lambda表達式中已經存在的方法。

Arrays.sort(stringsArray, String::compareToIgnoreCase);

這種特性就叫作方法引用(Method Reference)。

方法引用的形式 方法引用的標準形式是:類名::方法名。（注意：只須要寫方法名，不須要寫括號）

有如下四種形式的方法引用:

類型	示例
引用靜態方法	ContainingClass::staticMethodName
引用某個對象的實例方法	containingObject::instanceMethodName
引用某個類型的任意對象的實例方法	ContainingType::methodName
引用構造方法	ClassName::new

舉個栗子---

public class User {

    public static User create(Supplier<User> supplier) {
        System.out.println("create ");
        return supplier.get();
    }

    public static String name(User u) {
        System.out.println("name ");
        return "呵呵";
    }

    public int age(User u) {
        System.out.println("age ");
        return 18;
    }

}


public class MethodTest {

    public static void main(String[] args) {

        //構造器的引用
        User user = User.create(User::new);
        List<User> users = Arrays.asList(user);

        //靜態方法引用
        users.forEach(User::name);

        //對象方法的引用
        users.forEach(user::age);

        String[] stringsArray = {"Hello", "World"};

        //使用lambda表達式和類型對象的實例方法
        Arrays.sort(stringsArray, (s1, s2) -> s1.compareToIgnoreCase(s2));

        //使用方法引用
        //引用的是類型對象的實例方法
        Arrays.sort(stringsArray, String::compareToIgnoreCase);

        Arrays.asList(stringsArray).stream().forEach(x -> System.out.println(x));
        //引用的是類型對象的實例方法
        Arrays.asList(stringsArray).stream().forEach(System.out::println);


    }


}

##四、重複註解和新的target

public class RepeatingAnnotations {
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface Filters {
        Filter[] value();
    }

    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    @Repeatable( Filters.class )
    public @interface Filter {
        String value();
    };

    @Filter( "filter1" )
    @Filter( "filter2" )
    public interface Filterable {        
    }

    public static void main(String[] args) {
        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
            System.out.println( filter.value() );
        }
    }
}

正如咱們所見，這裏的Filter類使用@Repeatable(Filters.class)註解修飾，而Filters是存放Filter註解的容器，編譯器儘可能對開發者屏蔽這些細節。這樣，Filterable接口能夠用兩個Filter註解註釋（這裏並無提到任何關於Filters的信息）。
另外，反射API提供了一個新的方法：getAnnotationsByType()，能夠返回某個類型的重複註解，例如Filterable.class.getAnnoation(Filters.class)將返回兩個Filter實例，輸出到控制檯的內容以下所示：
filter1
filter2

###新的target 另外Java 8的註解還增長到兩種新的target上了：

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}

##五、更好的類型推薦

--好像沒什麼好說的。感受要去體會，呵呵。

##六、Optional Optional僅僅是一個容易：存放T類型的值或者null。它提供了一些有用的接口來避免顯式的null檢查

public class OptionalTest {

    public static void main(String[] args)  {
        Optional< String > fullName = Optional.ofNullable( null );
        //若是Optional實例持有一個非空值，則isPresent()方法返回true，不然返回false；
        System.out.println( "Full Name is set? " + fullName.isPresent() );

        //orElseGet()方法，Optional實例持有null，則能夠接受一個lambda表達式生成的默認值
        System.out.println( "Full Name: " + fullName.orElseGet( () -> "[none]" ) );

        //map()方法能夠將現有的Opetional實例的值轉換成新的值；
        System.out.println( fullName.map( s -> "Hey " + s + "!" ).orElse( "Hey Stranger!" ) );

        //orElse()方法與orElseGet()方法相似，可是在持有null的時候返回傳入的默認值
    }
}

輸出
Full Name is set? false
Full Name: [none]
Hey Stranger!

#七、Streams

public class StreamEntity {
    private String name;
    private int age;

    public StreamEntity(String name, int age) {
        this.name = name;
        this.age = age;
    }

------------------------

public class StreamTest {

    public static void main(String[] args) {

        List<StreamEntity> list = Arrays.asList(new StreamEntity("張三", 19), new StreamEntity("李四", 20), new StreamEntity
                ("王五", 18), new StreamEntity("呵呵", 19));


        int sum = list.stream().filter(u -> u.getAge() > 18).mapToInt(u -> u.getAge()).sum();

        System.out.println(sum);
    }
}


輸出 
58

list集合被轉換成steam表示；其次，在steam上的filter操做會過濾掉全部age大於18 的；第三，mapToInt操做基於每一個task實例的getAge方法將list流轉換成Integer集合；最後，經過sum方法計算總和，得出最後的結果。

** Steam之上的操做可分爲中間操做和晚期操做。 中間操做會返回一個新的steam——執行一箇中間操做（例如filter）並不會執行實際的過濾操做，而是建立一個新的steam，並將原steam中符合條件的元素放入新建立的steam。 晚期操做（例如forEach或者sum），會遍歷steam並得出結果或者附帶結果；在執行晚期操做以後，steam處理線已經處理完畢，就不能使用了。在幾乎全部狀況下，晚期操做都是馬上對steam進行遍歷。 steam的另外一個價值是創造性地支持並行處理（parallel processing） **

//parallel() 並行流
public class StreamTest {

    public static void main(String[] args) {

        List<StreamEntity> list = Arrays.asList(new StreamEntity("張三", 19), new StreamEntity("李四", 20), new StreamEntity
                ("王五", 18), new StreamEntity("呵呵", 19));


        int sum = list.stream().parallel().filter(u -> u.getAge() >= 19).mapToInt(u -> u.getAge()).reduce(0,(a,b)->a+b);
        int sum1 = list.stream().parallel().filter(u -> u.getAge() >= 19).mapToInt(u -> u.getAge()).reduce(0,
                Integer::sum);

        System.out.println(sum);
        System.out.println(sum1);
    }
}


//reduce  萬能的，，，後面博客介紹

輸出
58
58

###Stream的分組

Map<Integer, List< StreamEntity >> m = list.stream().parallel().collect(Collectors.groupingBy(streamEntity -> streamEntity.getAge()));

        m.forEach((k, v) -> System.out.println("key:value = " + k + ":" + v)  );

輸出

key:value = 18:[com.slife.java8.StreamEntity@71c7db30]
key:value = 19:[com.slife.java8.StreamEntity@19bb089b, com.slife.java8.StreamEntity@4563e9ab]
key:value = 20:[com.slife.java8.StreamEntity@11531931]

##Date/Time API

使用用Clock替代System.currentTimeMillis()和TimeZone.getDefault()。

final Clock clock = Clock.systemUTC();
        System.out.println(clock.instant());
        System.out.println(clock.millis());

輸出
2017-10-23T06:20:22.437Z
1508739622508


``
###LocalDate和LocalTime、LocalDateTime類

final LocalDate date = LocalDate.now(); final LocalDate dateFromClock = LocalDate.now( clock );

System.out.println( date ); System.out.println( dateFromClock );

// Get the local date and local time final LocalTime time = LocalTime.now(); final LocalTime timeFromClock = LocalTime.now( clock );

System.out.println( time ); System.out.println( timeFromClock );

須要特定時區的data/time信息，則可使用**ZoneDateTime**

final ZonedDateTime zonedDatetime = ZonedDateTime.now(); final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock ); final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );

System.out.println( zonedDatetime ); System.out.println( zonedDatetimeFromClock ); System.out.println( zonedDatetimeFromZone );

###**Duration**類，它持有的時間精確到秒和納秒
計算兩個日期的秒和天數

// Get duration between two dates final LocalDateTime from = LocalDateTime.of( 2016, Month.APRIL, 16, 0, 0, 0 ); final LocalDateTime to = LocalDateTime.of( 2017, Month.APRIL, 16, 23, 59, 59 );

final Duration duration = Duration.between( from, to ); System.out.println( "Duration in days: " + duration.toDays() ); System.out.println( "Duration in hours: " + duration.toHours() );

#Nashorn JavaScript引擎
Nashorn JavaScript引擎，使得咱們能夠在JVM上開發和運行JS應用。，容許Java和JavaScript交互使用



#Base64
java8提供了Base64的api




#並行、併發特性
parallelXXX ，

DoubleAccumulator
DoubleAdder
LongAccumulator
LongAdder


之後的博客中詳細介紹。



#VM的新特性
使用Metaspace（JEP 122）代替持久代（PermGen space）。在JVM參數方面，使用-XX:MetaSpaceSize和-XX:MaxMetaspaceSize代替原來的-XX:PermSize和-XX:MaxPermSize。



個人官網
![個人博客](https://github.com/javanan/javanan.github.io/blob/master/style/images/slifelogo.png?raw=true)

個人官網<http://guan2ye.com>
個人CSDN地址<http://blog.csdn.net/chenjianandiyi>
個人簡書地址<http://www.jianshu.com/u/9b5d1921ce34>
個人github<https://github.com/javanan>
個人碼雲地址<https://gitee.com/jamen/>
[阿里雲優惠券https://promotion.aliyun.com/ntms/act/ambassador/sharetouser.html?userCode=vf2b5zld&utm_source=vf2b5zld](https://promotion.aliyun.com/ntms/act/ambassador/sharetouser.html?userCode=vf2b5zld&utm_source=vf2b5zld)