JDK8那些惊为天人的新特性
分享一波:程序員賺外快-必看的巔峰干貨
介紹
隨著java的發(fā)展，越來越多的企業(yè)開始使用 java8 版本。Java8 是自 java5之后最重要的版本，這個版本包含語言、編譯器、庫、工具、JVM等方面的十多個新特性。本次課程將著重學習其中的一些重點特性。
Jdk8新增的特性如下：
Lambda表達式 類似于ES6中的箭頭函數(shù) 新的日期API Datetime 引入Optional 防止空指針異常 使用Base64 接口的默認方法和靜態(tài)方法 新增方法引用格式 新增Stream類 注解相關的改變 支持并行（parallel）數(shù)組 對并發(fā)類（Concurrency）的擴展。 JavaFX接口新特性
接口默認方法
當我們去實現(xiàn)某個框架提供的一個接口時，需要實現(xiàn)其所有的抽象方法，當該框架更新版本，在這個借口中加入了新的抽象方法時，我們就需要對項目重新編譯，并且實現(xiàn)其新增的方法。
當實現(xiàn)類太多時，操作起來很麻煩。
JDK之前是使用開閉設計模式：對擴展開放，對修改關閉。即：創(chuàng)建一個新的接口，繼承原有的接口，定義新的方法。
但是這樣的話，原本的那些實現(xiàn)類并沒有新的方法
這時候可以使用接口默認方法
關鍵字使用default進行修飾， 方法需要方法體。這樣的方法所有的子類會默認實現(xiàn)（不用自己寫），如果想要覆蓋重寫，也可以在實現(xiàn)類中覆蓋重寫
/**
-
從java8開始，接口當中允許定義default默認方法
-
修飾符：public default(public可以省略，default不能省略)
*/
public interface MyInterface {void method1();
void method2();
default void methodNew() {
System.out.println(“接口默認方法執(zhí)行”);
}
}
這里需要注意的是：這里的default是jdk8新增的關鍵字，和訪問限定修飾符“default”不是一個概念，與switch中的default功能完全不同.
與抽象類的不同：抽象類更多的是提供一個模板，子類之間的某個流程大致相同，僅僅是某個步驟可能不一樣（模板方法設計模式），這個時候使用抽象類，該步驟定義為抽象方法。而default關鍵字是用于擴展
接口靜態(tài)方法
/**
-
從java8開始，接口當中允許定義靜態(tài)方法
-
修飾符：static xxx
-
一般類的靜態(tài)方法用法相同
*/
public interface Animal {void eat();
static Animal getAnimal() {
return new Cat();
}
}
接口的靜態(tài)方法不會被實現(xiàn)類所繼承
函數(shù)式接口
概念
函數(shù)式接口在Java中是指：有且僅有一個抽象方法的接口。
函數(shù)式接口，即適用于函數(shù)式編程場景的接口。而Java中的函數(shù)式編程體現(xiàn)就是Lambda，所以函數(shù)式接口就是可以適用于Lambda使用的接口。只有確保接口中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。
格式
確保接口中有且只有一個抽象方法即可
Public interface 接口名稱 {
返回值 方法名稱();
}
@FunctionalInterface注解
有的注解是在編譯期起作用，如@Override注解。而@FunctionalInterface也是在編譯期起作用。該注解是java8專門為函數(shù)式接口引入的新的注解，作用于一個接口上。
一旦使用該注解來定義接口，編譯期會強制檢查該接口是否符合函數(shù)式接口的條件，不符合則會報錯。需要注意的是：即使不使用該注解，只要滿足函數(shù)式接口的定義，這就是一個函數(shù)式接口。
@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}
自定義函數(shù)式接口
public class DemoFunctionalInterface {
// 使用自定義的函數(shù)式接口作為方法參數(shù)
}
Lambda表達式
在面向對象的基礎上，java8 通過Lambda表達式與方法引用等，為開發(fā)者打開了函數(shù)式編程的大門。Lambda表達式不是語法糖，而是新的語法
語法
三要素：參數(shù)、箭頭、代碼
(參數(shù)類型 參數(shù)1, 參數(shù)類型 參數(shù)2…) -> {代碼}
如果參數(shù)有多個，那么使用逗號分隔。如果參數(shù)沒有，則留空 箭頭是固定寫法 大括號相當于方法體。使用Lambda表達式的必要前提：必須是函數(shù)式接口
Lambda 省略規(guī)則
Lambda的延遲執(zhí)行
有些場景的代碼執(zhí)行后，結果不一定會被使用，從而造成性能浪費。而Lambda表達式是延遲執(zhí)行的，這正好可以作為解決方案，提升性能。
性能浪費的案例
public class Demo01Logger {
private static void log(int level, String msg) {
if (level == 1) {
System.out.println(msg);
}
}
}
這段代碼存在問題：無論級別是否滿足要求，作為 log 方法的第二個參數(shù)，三個字符串一定會首先被拼接并傳入方法內，然后才會進行級別判斷。如果級別不符合要求，那么字符串的拼接操作就白做了，存在性能浪費。
Lambda的優(yōu)化寫法
@FunctionalInterface
public interface MessageBuilder {
String buildMessage();
}
public class Demo02LoggerLambda {
private static void log(int level, MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}
}
這樣一來，只有當滿足條件的時候才會進行三個字符串的拼接。否則不會拼接。
證明Lambda的延遲
public class Demo03LoggerDelay {
private static void log(int level, MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}
}
從結果可以看出，在不符合要求的情況下，lambda將不會執(zhí)行
使用Lambda作為參數(shù)和返回值
如果拋開實現(xiàn)原理不說，Java中的Lambda表達式可以被當作是匿名內部類的替代品。如果方法的參數(shù)是一個函數(shù)式接口類型，那么就可以使用Lambda表達式進行替代。使用Lambda表達式作為方法參數(shù)，其實就是使用函數(shù)式接口作為方法參數(shù)。
例如 java.lang.Runnable 接口就是一個函數(shù)式接口，假設有一個 startThread 方法使用該接口作為參數(shù)，那么就可以使用Lambda進行傳參。這種情況其實和 Thread 類的構造方法參數(shù)為 Runnable 沒有本質區(qū)別。
public class Demo04Runnable {
private static void startThread(Runnable task) {
new Thread(task).start();
}
}
類似地，如果一個方法的返回值類型是一個函數(shù)式接口，那么就可以直接返回一個Lambda表達式。當需要通過一個方法來獲取一個 java.util.Comparator 接口類型的對象作為排序器時,就可以調該方法獲取
public class Demo06Comparator {
private static Comparator newComparator() {
return (a, b) -> b.length() - a.length();
}
}
常用函數(shù)式接口
JDK提供了大量的函數(shù)式接口以及豐富的Lambda應用場景。下面是最簡單的幾個接口以及使用實例
Supplier
java.util.function.Supplier 接口僅包含一個無參的方法： T get() 。用來獲取一個泛型參數(shù)指定類型的對象數(shù)據(jù)。由于這是一個函數(shù)式接口，這也就意味著對應的Lambda表達式需要“對外提供”一個符合泛型類型的對象數(shù)據(jù)。
public class Demo08Supplier {
private static String getString(Supplier function) {
return function.get();
}
}
練習：求數(shù)組元素的最小值
public class Demo02Test {
//定一個方法,方法的參數(shù)傳遞Supplier,泛型使用Integer
public static int getMax(Supplier sup) {
return sup.get();
}
}
Consumer接口
java.util.function.Consumer 接口則正好與Supplier接口相反，它不是生產一個數(shù)據(jù)，而是消費一個數(shù)據(jù)，
其數(shù)據(jù)類型由泛型決定。
抽象方法：accept，意為消費一個指定泛型的數(shù)據(jù)
public class Demo09Consumer {
private static void consumeString(Consumer function) {
function.accept(“Hello”);
}
}
默認方法：andThen
如果一個方法的參數(shù)和返回值全都是 Consumer 類型，那么就可以實現(xiàn)效果：消費數(shù)據(jù)的時候，首先做一個操作，然后再做一個操作，實現(xiàn)組合。而這個方法就是 Consumer 接口中的default方法 andThen
要想實現(xiàn)組合，需要兩個或多個Lambda表達式即可，而 andThen 的語義正是“一步接一步”操作。例如兩個步驟組合的情況
public class Demo10ConsumerAndThen {
private static void consumeString(Consumer one, Consumer two) {
one.andThen(two).accept(“Hello”);
}
}
練習：格式化打印信息
下面的字符串數(shù)組當中存有多條信息，請按照格式“ 姓名：XX。性別：XX。 ”的格式將信息打印出來。要求將打印姓名的動作作為第一個 Consumer 接口的Lambda實例，將打印性別的動作作為第二個 Consumer 接口的Lambda實例，將兩個 Consumer 接口按照順序“拼接”到一起。
public class DemoConsumer {
public static void main(String[] args) {
String[] array = {“迪麗熱巴,女”, “古力娜扎,女”, “馬爾扎哈,男”};
printInfo(s -> System.out.print(“姓名：” + s.split(",")[0]), s ->
System.out.println("。性別：" + s.split(",")[1] + “。”), array);
}
}
Predicate接口
有時候我們需要對某種類型的數(shù)據(jù)進行判斷，從而得到一個boolean值結果。這時可以使用java.util.function.Predicate 接口。
抽象方法：test
Predicate 接口中包含一個抽象方法： boolean test(T t) 。用于條件判斷的場景：
public class Demo15PredicateTest {
private static void method(Predicate predicate) {
boolean veryLong = predicate.test(“HelloWorld”);
System.out.println(“字符串很長嗎：” + veryLong);
}
}
條件判斷的標準是傳入lambda表達式邏輯
默認方法：and
既然是條件判斷，就會存在與、或、非三種常見的邏輯關系。其中將兩個 Predicate 條件使用“與”邏輯連接起來實現(xiàn)“并且”的效果時，可以使用default方法 and
如果要判斷一個字符串既要包含大寫“H”，又要包含大寫“W”
public class Demo16PredicateAnd {
private static void method(Predicate one, Predicate two) {
boolean isValid = one.and(two).test(“Helloworld”);
System.out.println(“字符串符合要求嗎：” + isValid);
}
}
默認方法：or
如果希望實現(xiàn)邏輯“字符串包含大寫H或者包含大寫W”，那么代碼只需要將“and”修改為“or”名稱即可，其他都不變：
默認方法：negate
表示取反
public class Demo17PredicateNegate {
private static void method(Predicate predicate) {
boolean veryLong = predicate.negate().test(“HelloWorld”);
System.out.println(“字符串很長嗎：” + veryLong);
}
}
練習：集合信息篩選
數(shù)組當中有多條“姓名+性別”的信息如下，請通過 Predicate 接口的拼裝將符合要求的字符串篩選到集合ArrayList 中，需要同時滿足兩個條件：
必須為女生；
姓名為4個字。
public class DemoPredicate {
public static void main(String[] args) {
String[] array = {“迪麗熱巴,女”, “古力娜扎,女”, “馬爾扎哈,男”, “趙麗穎,女”};
List list = filter(array, s -> “女”.equals(s.split(",")[1]), s -> s.split(",")[0].length() == 4);
System.out.println(list);
}
}
Function接口
java.util.function.Function<T,R> 接口用來根據(jù)一個類型的數(shù)據(jù)得到另一個類型的數(shù)據(jù)，前者稱為前置條件，后者稱為后置條件。
抽象方法：apply
Function 接口中最主要的抽象方法為： R apply(T t) ，根據(jù)類型T的參數(shù)獲取類型R的結果。使用的場景例如：將 String 類型轉換為 Integer 類型
public class Demo11FunctionApply {
private static void method(Function<String, Integer> function) {
int num = function.apply(“10”);
System.out.println(num + 20);
}
}
默認方法：andThen
public class Demo12FunctionAndThen {
private static void method(Function<String, Integer> one, Function<Integer, Integer> two) {
int num = one.andThen(two).apply(“10”);
System.out.println(num + 20);
}
}
練習：自定義函數(shù)模型拼接
請使用 Function 進行函數(shù)模型的拼接，按照順序需要執(zhí)行的多個函數(shù)操作為：
String str = “趙麗穎,20”;
將字符串截取數(shù)字年齡部分，得到字符串；
將上一步的字符串轉換成為int類型的數(shù)字；
將上一步的int數(shù)字累加100，得到結果int數(shù)字。
public class DemoFunction {
public static void main(String[] args) {
String str = “趙麗穎,20”;
int age = getAgeNum(str, s -> s.split(",")[1], s -> Integer.parseInt(s), n -> n += 100);
System.out.println(age);
}
}
方法引用
冗余的Lambda場景
在使用Lambda表達式的時候，我們實際上傳遞進去的代碼就是一種解決方案：拿什么參數(shù)做什么操作。那么考慮一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重復邏輯？
先看一個簡單的函數(shù)式接口
@FunctionalInterface
public interface Printable {
void print(String str);
}
public class Demo01PrintSimple {
private static void printString(Printable data) {
data.print(“Hello, World!”);
}
}
其中 printString 方法只管調用 Printable 接口的 print 方法，而并不管 print 方法的具體實現(xiàn)邏輯會將字符串打印到什么地方去。而 main 方法通過Lambda表達式指定了函數(shù)式接口 Printable 的具體操作方案為：拿到String（類型可推導，所以可省略）數(shù)據(jù)后，在控制臺中輸出它。
問題分析
這段代碼的問題在于，對字符串進行控制臺打印輸出的操作方案，明明已經有了現(xiàn)成的實現(xiàn)，那就是 System.out對象中的 println(String) 方法。既然Lambda希望做的事情就是調用println(String) 方法，那何必自己手動調用呢？
能否省去Lambda的語法格式（盡管它已經相當簡潔）呢？只要“引用”過去就好了：
public class Demo02PrintRef {
private static void printString(Printable data) {
data.print(“Hello, World!”);
}
}
請注意其中的雙冒號 :: 寫法，這被稱為“方法引用”，而雙冒號是一種新的語法。
方法引用符
雙冒號 :: 為引用運算符，而它所在的表達式被稱為方法引用。如果Lambda要表達的函數(shù)方案已經存在于某個方法的實現(xiàn)中，那么則可以通過雙冒號來引用該方法作為Lambda的替代者。
語義分析
例如上例中， System.out 對象中有一個重載的 println(String) 方法恰好就是我們所需要的。那么對printString 方法的函數(shù)式接口參數(shù)，對比下面兩種寫法，完全等效：
Lambda表達式寫法： s -> System.out.println(s); 方法引用寫法： System.out::println第一種語義是指：拿到參數(shù)之后經Lambda之手，繼而傳遞給 System.out.println 方法去處理。
第二種等效寫法的語義是指：直接讓 System.out 中的 println 方法來取代Lambda。兩種寫法的執(zhí)行效果完全一樣，而第二種方法引用的寫法復用了已有方案，更加簡潔。
注:Lambda 中 傳遞的參數(shù) 一定是方法引用中 的那個方法可以接收的類型,否則會拋出異常
推導與省略
如果使用Lambda，那么根據(jù)“可推導就是可省略”的原則，無需指定參數(shù)類型，也無需指定的重載形式——它們都將被自動推導。而如果使用方法引用，也是同樣可以根據(jù)上下文進行推導。
函數(shù)式接口是Lambda的基礎，而方法引用是Lambda的孿生兄弟。
下面這段代碼將會調用 println 方法的不同重載形式，將函數(shù)式接口改為int類型的參數(shù)：
@FunctionalInterface
public interface PrintableInteger {
void print(int str);
}
由于上下文變了之后可以自動推導出唯一對應的匹配重載，所以方法引用沒有任何變化
public class Demo03PrintOverload {
private static void printInteger(PrintableInteger data) {
data.print(1024);
}
}
通過對象名引用成員方法
這是最常見的一種用法，與上例相同。如果一個類中已經存在了一個成員方法：
public class MethodRefObject {
public void printUpperCase(String str) {
System.out.println(str.toUpperCase());
}
}
那么當需要使用這個 printUpperCase 成員方法來替代 Printable 接口的Lambda的時候，已經具有了MethodRefObject 類的對象實例，則可以通過對象名引用成員方法，代碼為：
public class Demo04MethodRef {
private static void printString(Printable lambda) {
lambda.print(“Hello”);
}
}
通過類名稱引用靜態(tài)方法
由于在 java.lang.Math 類中已經存在了靜態(tài)方法 abs ，所以當我們需要通過Lambda來調用該方法時，有兩種寫法。首先是函數(shù)式接口：
@FunctionalInterface
public interface Calcable {
int calc(int num);
}
第一種寫法使用Lambda
public class Demo05Lambda {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
}
第二種使用方法引用
public class Demo06MethodRef {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}
}
兩種方式等價
通過super引用成員方法
如果存在繼承關系，當Lambda中需要出現(xiàn)super調用時，也可以使用方法引用進行替代。首先是函數(shù)式接口：
@FunctionalInterface
public interface Greetable {
void greet();
}
父類Human的內容
public class Human {
public void sayHello() {
System.out.println(“Hello!”);
}
}
子類Man的內容
public class Man extends Human {
@Override
public void sayHello() {
System.out.println(“大家好,我是Man!”);
}
}
但是如果使用方法引用會更好
public class Woman extends Human {
@Override
public void sayHello() {
System.out.println(“大家好,我是Man!”);
}
}
通過this引用成員方法
this代表當前對象，如果需要引用的方法就是當前類中的成員方法，那么可以使用“this::成員方法”的格式來使用方法引用。首先是簡單的函數(shù)式接口：
@FunctionalInterface
public interface Richable {
void buy();
}
public class Husband {
private void marry(Richable lambda) {
lambda.buy();
}
}
開心方法 beHappy 調用了結婚方法 marry ，后者的參數(shù)為函數(shù)式接口 Richable ，所以需要一個Lambda表達式。但是如果這個Lambda表達式的內容已經在本類當中存在了，則可以對 Husband 丈夫類進行修改：
public class Husband {
private void buyHouse() {
System.out.println(“買套房子”);
}
}
Stream流
說到Stream便容易想到I/O Stream，而實際上，在Java 8中，得益于Lambda所帶來的函數(shù)式編程，引入了一個全新的Stream概念，用于解決已有集合類庫既有的弊端。
Stream流式操作性能比傳統(tǒng)的For循環(huán)要低，就性能而言，傳統(tǒng)的for循環(huán)最高
傳統(tǒng)集合的遍歷代碼
幾乎所有的集合（如 Collection 接口或 Map 接口等）都支持直接或間接的遍歷操作。而當我們需要對集合中的元素進行操作的時候，除了必需的添加、刪除、獲取外，最典型的就是集合遍歷。例如：
public class Demo01ForEach {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(“張無忌”);
list.add(“周芷若”);
list.add(“趙敏”);
list.add(“張強”);
list.add(“張三豐”);
for (String name : list) {
System.out.println(name);
}
}
}
循環(huán)遍歷的弊端
Java 8的Lambda讓我們可以更加專注于做什么（What），而不是怎么做（How），這點此前已經結合內部類進行了對比說明。現(xiàn)在，我們仔細體會一下上例代碼，可以發(fā)現(xiàn)：
for循環(huán)的語法就是“怎么做” for循環(huán)的循環(huán)體才是“做什么”為什么使用循環(huán)？因為要進行遍歷。但循環(huán)是遍歷的唯一方式嗎？遍歷是指每一個元素逐一進行處理，而并不是從第一個到最后一個順次處理的循環(huán)。前者是目的，后者是方式。
試想一下，如果希望對集合中的元素進行篩選過濾：
將集合A根據(jù)條件一過濾為子集B； 然后再根據(jù)條件二過濾為子集C。那怎么辦？在Java 8之前的做法可能為：
public class Demo02NormalFilter {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(“張無忌”);
list.add(“周芷若”);
list.add(“趙敏”);
list.add(“張強”);
list.add(“張三豐”);
List zhangList = new ArrayList<>();
for (String name : list) {
if (name.startsWith(“張”)) {
zhangList.add(name);
}
}
List shortList = new ArrayList<>();
for (String name : zhangList) {
if (name.length() == 3) {
shortList.add(name);
}
}
for (String name : shortList) {
System.out.println(name);
}
}
}
這段代碼中含有三個循環(huán)，每一個作用不同：
首先篩選所有姓張的人；
然后篩選名字有三個字的人；
最后進行對結果進行打印輸出。
每當我們需要對集合中的元素進行操作的時候，總是需要進行循環(huán)、循環(huán)、再循環(huán)。這是理所當然的么？不是。循環(huán)是做事情的方式，而不是目的。另一方面，使用線性循環(huán)就意味著只能遍歷一次。如果希望再次遍歷，只能再使用另一個循環(huán)從頭開始。
那，Lambda的衍生物Stream能給我們帶來怎樣更加優(yōu)雅的寫法呢？
Stream更優(yōu)寫法
public class Demo03StreamFilter {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(“張無忌”);
list.add(“周芷若”);
list.add(“趙敏”);
list.add(“張強”);
list.add(“張三豐”);
list.stream().filter(s -> s.startsWith(“張”))
.filter(s -> s.length() == 3)
.forEach(System.out::println);
}
}
直接閱讀代碼的字面意思即可完美展示無關邏輯方式的語義：獲取流、過濾姓張、過濾長度為3、逐一打印。代碼中并沒有體現(xiàn)使用線性循環(huán)或是其他任何算法進行遍歷，我們真正要做的事情內容被更好地體現(xiàn)在代碼中。
獲取流
java.util.stream.Stream 是Java 8新加入的最常用的流接口。（這并不是一個函數(shù)式接口。）
獲取一個流非常簡單，有以下幾種常用的方式：
所有的 Collection 集合都可以通過 stream 默認方法獲取流； Stream 接口的靜態(tài)方法 of 可以獲取數(shù)組對應的流。根據(jù)Collection獲取流
首先， java.util.Collection 接口中加入了default方法 stream 用來獲取流，所以其所有實現(xiàn)類均可獲取流。
public class Demo04GetStream {
public static void main(String[] args) {
List list = new ArrayList<>();
Stream stream1 = list.stream();
Set set = new HashSet<>();
Stream stream2 = set.stream();
}
}
根據(jù)Map獲取流
java.util.Map 接口不是 Collection 的子接口，且其K-V數(shù)據(jù)結構不符合流元素的單一特征，所以獲取對應的流
需要分key、value或entry等情況：
public class Demo05GetStream {
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
Stream keyStream = map.keySet().stream();
Stream valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
}
}
根據(jù)數(shù)組獲取流
如果使用的不是集合或映射而是數(shù)組，由于數(shù)組對象不可能添加默認方法，所以 Stream 接口中提供了靜態(tài)方法
of ，使用很簡單：
public class Demo06GetStream {
public static void main(String[] args) {
String[] array = {“張無忌”, “張翠山”, “張三豐”, “張一元”};
Stream stream = Stream.of(array);
}
}
常用方法
逐一處理：forEach
雖然方法名字叫forEach，但是與for循環(huán)不同
基本使用
public class Demo12StreamForEach {
public static void main(String[] args) {
Stream stream = Stream.of(“張無忌”, “張三豐”, “周芷若”);
stream.forEach(name -> System.out.println(name));
}
}
過濾：filter
可以通過 filter 方法將一個流轉換成另一個子集流
public class Demo07StreamFilter {
public static void main(String[] args) {
Stream original = Stream.of(“張無忌”, “張三豐”, “周芷若”);
Stream result = original.filter(s -> s.startsWith(“張”));
}
}
在這里通過Lambda表達式來指定了篩選的條件：必須姓張。
映射：map
如果需要將流中的元素映射到另一個流中，可以使用 map 方法。方法簽名：
public class Demo08StreamMap {
public static void main(String[] args) {
Stream original = Stream.of(“10”, “12”, “18”);
Stream result = original.map(str -> Integer.parseInt(str));
}
}
這段代碼中， map 方法的參數(shù)通過方法引用，將字符串類型轉換成為了int類型（并自動裝箱為 Integer 類對象）。
統(tǒng)計個數(shù)：count
public class Demo09StreamCount {
public static void main(String[] args) {
Stream original = Stream.of(“張無忌”, “張三豐”, “周芷若”);
Stream result = original.filter(s -> s.startsWith(“張”));
System.out.println(result.count());
}
}
取用前幾個：limit
public class Demo10StreamLimit {
public static void main(String[] args) {
Stream original = Stream.of(“張無忌”, “張三豐”, “周芷若”);
Stream result = original.limit(2);
System.out.println(result.count());
}
}
跳過前幾個：skip
public class Demo11StreamSkip {
public static void main(String[] args) {
Stream original = Stream.of(“張無忌”, “張三豐”, “周芷若”);
Stream result = original.skip(2);
System.out.println(result.count());
}
}
組合：concat
如果有兩個流，希望合并成為一個流，那么可以使用 Stream 接口的靜態(tài)方法 concat
public class Demo12StreamConcat {
public static void main(String[] args) {
Stream streamA = Stream.of(“張無忌”);
Stream streamB = Stream.of(“張翠山”);
Stream result = Stream.concat(streamA, streamB);
}
}
練習：集合元素處理（傳統(tǒng)方式）
現(xiàn)在有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統(tǒng)的for循環(huán)（或增強for循環(huán)）依次進行以下若干操作步驟：
第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。
第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。
第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。
第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。
將兩個隊伍合并為一個隊伍；存儲到一個新集合中。
根據(jù)姓名創(chuàng)建 Person 對象；存儲到一個新集合中。
打印整個隊伍的Person對象信息。
代碼如下：
public class DemoArrayListNames {
public static void main(String[] args) {
ArrayList one = new ArrayList<>();
one.add(“迪麗熱巴”);
one.add(“宋遠橋”);
one.add(“蘇星河”);
one.add(“石破天”);
one.add(“石中玉”);
one.add(“老子”);
one.add(“莊子”);
one.add(“洪七公”);
ArrayList two = new ArrayList<>();
two.add(“古力娜扎”);
two.add(“張無忌”);
two.add(“趙麗穎”);
two.add(“張三豐”);
two.add(“尼古拉斯趙四”);
two.add(“張?zhí)鞇邸?;
two.add(“張二狗”);
}
public class Person {
private String name;
}
練習：集合元素處理（Stream方式）
public class DemoStreamNames {
public static void main(String[] args) {
List one = new ArrayList<>();
List two = new ArrayList<>();
// 第一個隊伍只要名字為3個字的成員姓名；
// 第一個隊伍篩選之后只要前3個人；
Stream streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
// 第二個隊伍只要姓張的成員姓名；
// 第二個隊伍篩選之后不要前2個人；
Stream streamTwo = two.stream().filter(s -> s.startsWith(“張”)).skip(2);
// 將兩個隊伍合并為一個隊伍；
// 根據(jù)姓名創(chuàng)建Person對象；
// 打印整個隊伍的Person對象信息。
Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
}
}
*************************************優(yōu)雅的分割線 **********************************
分享一波:程序員賺外快-必看的巔峰干貨
如果以上內容對你覺得有用,并想獲取更多的賺錢方式和免費的技術教程
請關注微信公眾號:HB荷包
一個能讓你學習技術和賺錢方法的公眾號,持續(xù)更新
總結
以上是生活随笔為你收集整理的JDK8那些惊为天人的新特性的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Android studio gradl
- 下一篇： 代码质量管理工具】——sonar