Java8放棄系列之-1.1-介紹
推薦、參考資料
中文API：中文API
扯淡
java8相對以前的版本應該說是一個重要的版本：看過一個笑話，大概是–》
今天CTO推薦了一個10年程式設計經驗的大牛來公司面試。正好主程在開會，於是叫了一個應屆生去面試，本想就走個流程，但是沒想到，最後這個大牛被拒了。主程問這位應屆生，怎麼回事。應屆生不屑的說，一問三不知，Lambda，Stream都沒聽說過。
新特性
1、Lambda表示式和函式式介面
由逗號分隔的引數列表、->符號和語句塊組成
public static void main(String[] args) {
List<String> list 函式介面指的是隻有一個函式的介面，這樣的介面可以隱式轉換為Lambda表示式。java.lang.Runnable和java.util.concurrent.Callable是函式式介面的最佳例子。
顯式說明某個介面是函式式介面，Java 8 提供了一個特殊的註解@FunctionalInterface（Java 庫中的所有相關介面都已經帶有這個註解了），舉個簡單的函式式介面的定義：
@FunctionalInterface
public interface FunctionalDefaultMethods {
void method();
default void defaultMethod() {
}
}預設方法和靜態方法不會破壞函式式介面的定義，因此如下的程式碼是合法的。
@FunctionalInterface
public 2、介面的預設方法、靜態方法
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();
}
}3、方法引用
在學習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);
}
}
4、重複註解和新的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 {}
5、更好的型別推薦
–好像沒什麼好說的。感覺要去體會，呵呵。
6、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!7、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。
我的官網
