介紹

隨著java的發展，越來越多的企業開始使用 java8 版本。Java8 是自 java5之后最重要的版本，這個版本包含語言、編譯器、庫、工具、JVM等方面的十多個新特性。本次課程將著重學習其中的一些重點特性。

Jdk8新增的特性如下：

Lambda表達式 類似于ES6中的箭頭函數
新的日期API Datetime
引入Optional 防止空指針異常
使用Base64
接口的默認方法和靜態方法
新增方法引用格式
新增Stream類
注解相關的改變
支持并行（parallel）數組
對并發類（Concurrency）的擴展。
JavaFX

接口新特性
接口默認方法

當我們去實現某個框架提供的一個接口時，需要實現其所有的抽象方法，當該框架更新版本，在這個借口中加入了新的抽象方法時，我們就需要對項目重新編譯，并且實現其新增的方法。

當實現類太多時，操作起來很麻煩。

JDK之前是使用開閉設計模式：對擴展開放，對修改關閉。即：創建一個新的接口，繼承原有的接口，定義新的方法。

但是這樣的話，原本的那些實現類并沒有新的方法

這時候可以使用接口默認方法

關鍵字使用default進行修飾， 方法需要方法體。這樣的方法所有的子類會默認實現（不用自己寫），如果想要覆蓋重寫，也可以在實現類中覆蓋重寫

/**

• 從java8開始，接口當中允許定義default默認方法

• 修飾符：public default(public可以省略，default不能省略)
  */
  public interface MyInterface {

  void method1();

  void method2();

  default void methodNew() {
  System.out.println(“接口默認方法執行”);
  }

}

這里需要注意的是：這里的default是jdk8新增的關鍵字，和訪問限定修飾符“default”不是一個概念，與switch中的default功能完全不同.

與抽象類的不同：抽象類更多的是提供一個模板，子類之間的某個流程大致相同，僅僅是某個步驟可能不一樣（模板方法設計模式），這個時候使用抽象類，該步驟定義為抽象方法。而default關鍵字是用于擴展
接口靜態方法

/**

• 從java8開始，接口當中允許定義靜態方法

• 修飾符：static xxx

• 一般類的靜態方法用法相同
  */
  public interface Animal {

  void eat();

  static Animal getAnimal() {
  return new Cat();
  }
  }

接口的靜態方法不會被實現類所繼承
函數式接口
概念

函數式接口在Java中是指：有且僅有一個抽象方法的接口。

函數式接口，即適用于函數式編程場景的接口。而Java中的函數式編程體現就是Lambda，所以函數式接口就是可以適用于Lambda使用的接口。只有確保接口中有且僅有一個抽象方法，Java中的Lambda才能順利地進行推導。
格式

確保接口中有且只有一個抽象方法即可

Public interface 接口名稱 {
返回值 方法名稱();
}

@FunctionalInterface注解

有的注解是在編譯期起作用，如@Override注解。而@FunctionalInterface也是在編譯期起作用。該注解是java8專門為函數式接口引入的新的注解，作用于一個接口上。

一旦使用該注解來定義接口，編譯期會強制檢查該接口是否符合函數式接口的條件，不符合則會報錯。需要注意的是：即使不使用該注解，只要滿足函數式接口的定義，這就是一個函數式接口。

@FunctionalInterface
public interface MyFunctionalInterface {
void myMethod();
}

自定義函數式接口

public class DemoFunctionalInterface {
// 使用自定義的函數式接口作為方法參數

private static void doSomething(MyFunctionalInterface inter) {inter.myMethod();
}public static void main(String[] args) {// 調用使用函數式接口的方法doSomething(() -> System.out.println("烏鴉坐飛機"));
}

}

Lambda表達式

在面向對象的基礎上，java8 通過Lambda表達式與方法引用等，為開發者打開了函數式編程的大門。Lambda表達式不是語法糖，而是新的語法
語法

三要素：參數、箭頭、代碼

(參數類型 參數1, 參數類型 參數2…) -> {代碼}

如果參數有多個，那么使用逗號分隔。如果參數沒有，則留空
箭頭是固定寫法
大括號相當于方法體。

使用Lambda表達式的必要前提：必須是函數式接口
Lambda 省略規則

參數類型可以省略。但是只能同時省略所有參數的類型，或者干脆都不省略。
如果參數有且僅有一個，那么小括號可以省略。
如果大括號內的語句有且僅有一條，那么無論是否有返回值，return、大括號、分號都可以省略

Lambda的延遲執行

有些場景的代碼執行后，結果不一定會被使用，從而造成性能浪費。而Lambda表達式是延遲執行的，這正好可以作為解決方案，提升性能。
性能浪費的案例

public class Demo01Logger {
private static void log(int level, String msg) {
if (level == 1) {
System.out.println(msg);
}
}

public static void main(String[] args) {String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, msgA + msgB + msgC);
}

}

這段代碼存在問題：無論級別是否滿足要求，作為 log 方法的第二個參數，三個字符串一定會首先被拼接并傳入方法內，然后才會進行級別判斷。如果級別不符合要求，那么字符串的拼接操作就白做了，存在性能浪費。

Lambda的優化寫法

@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());
}
}

public static void main(String[] args) {String msgA = "Hello";String msgB = "World";String msgC = "Java";log(1, () -> msgA + msgB + msgC );
}

}

這樣一來，只有當滿足條件的時候才會進行三個字符串的拼接。否則不會拼接。

證明Lambda的延遲

public class Demo03LoggerDelay {
private static void log(int level, MessageBuilder builder) {
if (level == 1) {
System.out.println(builder.buildMessage());
}
}

public static void main(String[] args) {String msgA = "Hello";String msgB = "World";String msgC = "Java";log(2, () -> {System.out.println("Lambda執行！");return msgA + msgB + msgC;});
}

}

從結果可以看出，在不符合要求的情況下，lambda將不會執行
使用Lambda作為參數和返回值

如果拋開實現原理不說，Java中的Lambda表達式可以被當作是匿名內部類的替代品。如果方法的參數是一個函數式接口類型，那么就可以使用Lambda表達式進行替代。使用Lambda表達式作為方法參數，其實就是使用函數式接口作為方法參數。

例如 java.lang.Runnable 接口就是一個函數式接口，假設有一個 startThread 方法使用該接口作為參數，那么就可以使用Lambda進行傳參。這種情況其實和 Thread 類的構造方法參數為 Runnable 沒有本質區別。

public class Demo04Runnable {
private static void startThread(Runnable task) {
new Thread(task).start();
}

public static void main(String[] args) {startThread(() -> System.out.println("線程任務執行！"));
}

}

類似地，如果一個方法的返回值類型是一個函數式接口，那么就可以直接返回一個Lambda表達式。當需要通過一個方法來獲取一個 java.util.Comparator 接口類型的對象作為排序器時,就可以調該方法獲取

public class Demo06Comparator {
private static Comparator newComparator() {
return (a, b) -> b.length() - a.length();
}

public static void main(String[] args) {String[] array = {"abc", "ab", "abcd"};System.out.println(Arrays.toString(array));Arrays.sort(array, newComparator());System.out.println(Arrays.toString(array));
}

}

常用函數式接口

JDK提供了大量的函數式接口以及豐富的Lambda應用場景。下面是最簡單的幾個接口以及使用實例

Supplier

java.util.function.Supplier 接口僅包含一個無參的方法： T get() 。用來獲取一個泛型參數指定類型的對象數據。由于這是一個函數式接口，這也就意味著對應的Lambda表達式需要“對外提供”一個符合泛型類型的對象數據。

public class Demo08Supplier {
private static String getString(Supplier function) {
return function.get();
}

public static void main(String[] args) {String msgA = "Hello";String msgB = "World";System.out.println(getString(() -> msgA + msgB));
}

}

練習：求數組元素的最小值

public class Demo02Test {
//定一個方法,方法的參數傳遞Supplier,泛型使用Integer
public static int getMax(Supplier sup) {
return sup.get();
}

public static void main(String[] args) {int arr[] = {2, 3, 4, 52, 333, 23};//調用getMax方法,參數傳遞Lambda int maxNum = getMax(() -> {//計算數組的最大值 int max = arr[0];for (int i : arr) {if (i > max) {max = i;}}return max;});System.out.println(maxNum);
}

}

Consumer接口

java.util.function.Consumer 接口則正好與Supplier接口相反，它不是生產一個數據，而是消費一個數據，

其數據類型由泛型決定。

抽象方法：accept，意為消費一個指定泛型的數據

public class Demo09Consumer {
private static void consumeString(Consumer function) {
function.accept(“Hello”);
}

public static void main(String[] args) {consumeString(s -> System.out.println(s));
}

}

默認方法：andThen

如果一個方法的參數和返回值全都是 Consumer 類型，那么就可以實現效果：消費數據的時候，首先做一個操作，然后再做一個操作，實現組合。而這個方法就是 Consumer 接口中的default方法 andThen

要想實現組合，需要兩個或多個Lambda表達式即可，而 andThen 的語義正是“一步接一步”操作。例如兩個步驟組合的情況

public class Demo10ConsumerAndThen {
private static void consumeString(Consumer one, Consumer two) {
one.andThen(two).accept(“Hello”);
}

public static void main(String[] args) {consumeString(s -> System.out.println(s.toUpperCase()), s -> System.out.println(s.toLowerCase()));
}

}

練習：格式化打印信息

下面的字符串數組當中存有多條信息，請按照格式“ 姓名：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);
}

private static void printInfo(Consumer<String> one, Consumer<String> two, String[] array) {for (String info : array) {one.andThen(two).accept(info); // 姓名：迪麗熱巴。性別：女。 }
}

}

Predicate接口

有時候我們需要對某種類型的數據進行判斷，從而得到一個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);
}

public static void main(String[] args) {method(s -> s.length() > 5);
}

}

條件判斷的標準是傳入lambda表達式邏輯

默認方法：and

既然是條件判斷，就會存在與、或、非三種常見的邏輯關系。其中將兩個 Predicate 條件使用“與”邏輯連接起來實現“并且”的效果時，可以使用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);
}

public static void main(String[] args) {method(s -> s.contains("H"), s -> s.contains("W"));
}

}

默認方法：or

如果希望實現邏輯“字符串包含大寫H或者包含大寫W”，那么代碼只需要將“and”修改為“or”名稱即可，其他都不變：

默認方法：negate

表示取反

public class Demo17PredicateNegate {
private static void method(Predicate predicate) {
boolean veryLong = predicate.negate().test(“HelloWorld”);
System.out.println(“字符串很長嗎：” + veryLong);
}

public static void main(String[] args) {method(s -> s.length() < 5);
}

}

練習：集合信息篩選

數組當中有多條“姓名+性別”的信息如下，請通過 Predicate 接口的拼裝將符合要求的字符串篩選到集合ArrayList 中，需要同時滿足兩個條件：

1. 必須為女生；

2. 姓名為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);
}

private static List<String> filter(String[] array, Predicate<String> one, Predicate<String> two) {List<String> list = new ArrayList<>();for (String info : array) {if (one.and(two).test(info)) {list.add(info);}}return list;
}

}

Function接口

java.util.function.Function<T,R> 接口用來根據一個類型的數據得到另一個類型的數據，前者稱為前置條件，后者稱為后置條件。

抽象方法：apply

Function 接口中最主要的抽象方法為： R apply(T t) ，根據類型T的參數獲取類型R的結果。使用的場景例如：將 String 類型轉換為 Integer 類型

public class Demo11FunctionApply {
private static void method(Function<String, Integer> function) {
int num = function.apply(“10”);
System.out.println(num + 20);
}

public static void main(String[] args) {method(s -> Integer.parseInt(s));
}

}

默認方法：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);
}

public static void main(String[] args) {method(str -> Integer.parseInt(str) + 10, i -> i *= 10);
}

}

練習：自定義函數模型拼接

請使用 Function 進行函數模型的拼接，按照順序需要執行的多個函數操作為：

String str = “趙麗穎,20”;

1. 將字符串截取數字年齡部分，得到字符串；

2. 將上一步的字符串轉換成為int類型的數字；

3. 將上一步的int數字累加100，得到結果int數字。

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);
}

private static int getAgeNum(String str, Function<String, String> one, Function<String, Integer> two, Function<Integer, Integer> three) {return one.andThen(two).andThen(three).apply(str);
}

}

方法引用
冗余的Lambda場景

在使用Lambda表達式的時候，我們實際上傳遞進去的代碼就是一種解決方案：拿什么參數做什么操作。那么考慮一種情況：如果我們在Lambda中所指定的操作方案，已經有地方存在相同方案，那是否還有必要再寫重復邏輯？

先看一個簡單的函數式接口

@FunctionalInterface
public interface Printable {
void print(String str);
}

public class Demo01PrintSimple {
private static void printString(Printable data) {
data.print(“Hello, World!”);
}

public static void main(String[] args) {printString(s -> System.out.println(s));
}

}

其中 printString 方法只管調用 Printable 接口的 print 方法，而并不管 print 方法的具體實現邏輯會將字符串打印到什么地方去。而 main 方法通過Lambda表達式指定了函數式接口 Printable 的具體操作方案為：拿到String（類型可推導，所以可省略）數據后，在控制臺中輸出它。
問題分析

這段代碼的問題在于，對字符串進行控制臺打印輸出的操作方案，明明已經有了現成的實現，那就是 System.out對象中的 println(String) 方法。既然Lambda希望做的事情就是調用println(String) 方法，那何必自己手動調用呢？

能否省去Lambda的語法格式（盡管它已經相當簡潔）呢？只要“引用”過去就好了：

public class Demo02PrintRef {
private static void printString(Printable data) {
data.print(“Hello, World!”);
}

public static void main(String[] args) {printString(System.out::println);
}

}

請注意其中的雙冒號 :: 寫法，這被稱為“方法引用”，而雙冒號是一種新的語法。
方法引用符

雙冒號 :: 為引用運算符，而它所在的表達式被稱為方法引用。如果Lambda要表達的函數方案已經存在于某個方法的實現中，那么則可以通過雙冒號來引用該方法作為Lambda的替代者。

語義分析

例如上例中， System.out 對象中有一個重載的 println(String) 方法恰好就是我們所需要的。那么對printString 方法的函數式接口參數，對比下面兩種寫法，完全等效：

Lambda表達式寫法： s -> System.out.println(s);
方法引用寫法： System.out::println

第一種語義是指：拿到參數之后經Lambda之手，繼而傳遞給 System.out.println 方法去處理。

第二種等效寫法的語義是指：直接讓 System.out 中的 println 方法來取代Lambda。兩種寫法的執行效果完全一樣，而第二種方法引用的寫法復用了已有方案，更加簡潔。

注:Lambda 中 傳遞的參數 一定是方法引用中 的那個方法可以接收的類型,否則會拋出異常

推導與省略

如果使用Lambda，那么根據“可推導就是可省略”的原則，無需指定參數類型，也無需指定的重載形式——它們都將被自動推導。而如果使用方法引用，也是同樣可以根據上下文進行推導。

函數式接口是Lambda的基礎，而方法引用是Lambda的孿生兄弟。

下面這段代碼將會調用 println 方法的不同重載形式，將函數式接口改為int類型的參數：

@FunctionalInterface
public interface PrintableInteger {
void print(int str);
}

由于上下文變了之后可以自動推導出唯一對應的匹配重載，所以方法引用沒有任何變化

public class Demo03PrintOverload {
private static void printInteger(PrintableInteger data) {
data.print(1024);
}

public static void main(String[] args) {printInteger(System.out::println);
}

}

通過對象名引用成員方法

這是最常見的一種用法，與上例相同。如果一個類中已經存在了一個成員方法：

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”);
}

public static void main(String[] args) {MethodRefObject obj = new MethodRefObject();printString(obj::printUpperCase);
}

}

通過類名稱引用靜態方法

由于在 java.lang.Math 類中已經存在了靜態方法 abs ，所以當我們需要通過Lambda來調用該方法時，有兩種寫法。首先是函數式接口：

@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 static void main(String[] args) {method(-10, n -> Math.abs(n));
}

}

第二種使用方法引用

public class Demo06MethodRef {
private static void method(int num, Calcable lambda) {
System.out.println(lambda.calc(num));
}

public static void main(String[] args) {method(-10, Math::abs);
}

}

兩種方式等價
通過super引用成員方法

如果存在繼承關系，當Lambda中需要出現super調用時，也可以使用方法引用進行替代。首先是函數式接口：

@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!”);
}

//定義方法method,參數傳遞Greetable接口 
public void method(Greetable g) {g.greet();
}public void show() {//調用method方法,使用Lambda表達式 method(() -> {//創建Human對象,調用sayHello方法 new Human().sayHello();});//簡化Lambda method(() -> new Human().sayHello());//使用super關鍵字代替父類對象 method(() -> super.sayHello());
}

}

但是如果使用方法引用會更好

public class Woman extends Human {
@Override
public void sayHello() {
System.out.println(“大家好,我是Man!”);
}

public void method(Greetable g) {g.greet();
}public void show() {method(super::sayHello);
}

}

通過this引用成員方法

this代表當前對象，如果需要引用的方法就是當前類中的成員方法，那么可以使用“this::成員方法”的格式來使用方法引用。首先是簡單的函數式接口：

@FunctionalInterface
public interface Richable {
void buy();
}

public class Husband {
private void marry(Richable lambda) {
lambda.buy();
}

public void beHappy() {marry(() -> System.out.println("買套房子"));
}

}

開心方法 beHappy 調用了結婚方法 marry ，后者的參數為函數式接口 Richable ，所以需要一個Lambda表達式。但是如果這個Lambda表達式的內容已經在本類當中存在了，則可以對 Husband 丈夫類進行修改：

public class Husband {
private void buyHouse() {
System.out.println(“買套房子”);
}

private void marry(Richable lambda) {lambda.buy();
}public void beHappy() {marry(this::buyHouse);
}

}

Stream流

說到Stream便容易想到I/O Stream，而實際上，在Java 8中，得益于Lambda所帶來的函數式編程，引入了一個全新的Stream概念，用于解決已有集合類庫既有的弊端。

Stream流式操作性能比傳統的For循環要低，就性能而言，傳統的for循環最高
傳統集合的遍歷代碼

幾乎所有的集合（如 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);
}
}
}

循環遍歷的弊端

Java 8的Lambda讓我們可以更加專注于做什么（What），而不是怎么做（How），這點此前已經結合內部類進行了對比說明。現在，我們仔細體會一下上例代碼，可以發現：

for循環的語法就是“怎么做”
for循環的循環體才是“做什么”

為什么使用循環？因為要進行遍歷。但循環是遍歷的唯一方式嗎？遍歷是指每一個元素逐一進行處理，而并不是從第一個到最后一個順次處理的循環。前者是目的，后者是方式。

試想一下，如果希望對集合中的元素進行篩選過濾：

將集合A根據條件一過濾為子集B；
然后再根據條件二過濾為子集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);
}
}
}

這段代碼中含有三個循環，每一個作用不同：

1. 首先篩選所有姓張的人；

2. 然后篩選名字有三個字的人；

3. 最后進行對結果進行打印輸出。

每當我們需要對集合中的元素進行操作的時候，總是需要進行循環、循環、再循環。這是理所當然的么？不是。循環是做事情的方式，而不是目的。另一方面，使用線性循環就意味著只能遍歷一次。如果希望再次遍歷，只能再使用另一個循環從頭開始。

那，Lambda的衍生物Stream能給我們帶來怎樣更加優雅的寫法呢？
Stream更優寫法

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、逐一打印。代碼中并沒有體現使用線性循環或是其他任何算法進行遍歷，我們真正要做的事情內容被更好地體現在代碼中。
獲取流

java.util.stream.Stream 是Java 8新加入的最常用的流接口。（這并不是一個函數式接口。）

獲取一個流非常簡單，有以下幾種常用的方式：

所有的 Collection 集合都可以通過 stream 默認方法獲取流；
Stream 接口的靜態方法 of 可以獲取數組對應的流。

根據Collection獲取流

首先， java.util.Collection 接口中加入了default方法 stream 用來獲取流，所以其所有實現類均可獲取流。

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();
}
}

根據Map獲取流

java.util.Map 接口不是 Collection 的子接口，且其K-V數據結構不符合流元素的單一特征，所以獲取對應的流

需要分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();
}
}

根據數組獲取流

如果使用的不是集合或映射而是數組，由于數組對象不可能添加默認方法，所以 Stream 接口中提供了靜態方法

of ，使用很簡單：

public class Demo06GetStream {
public static void main(String[] args) {
String[] array = {“張無忌”, “張翠山”, “張三豐”, “張一元”};
Stream stream = Stream.of(array);
}
}

常用方法
逐一處理：forEach

雖然方法名字叫forEach，但是與for循環不同

基本使用

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 方法的參數通過方法引用，將字符串類型轉換成為了int類型（并自動裝箱為 Integer 類對象）。
統計個數：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 接口的靜態方法 concat

public class Demo12StreamConcat {
public static void main(String[] args) {
Stream streamA = Stream.of(“張無忌”);
Stream streamB = Stream.of(“張翠山”);
Stream result = Stream.concat(streamA, streamB);
}
}

練習：集合元素處理（傳統方式）

現在有兩個 ArrayList 集合存儲隊伍當中的多個成員姓名，要求使用傳統的for循環（或增強for循環）依次進行以下若干操作步驟：

1. 第一個隊伍只要名字為3個字的成員姓名；存儲到一個新集合中。

2. 第一個隊伍篩選之后只要前3個人；存儲到一個新集合中。

3. 第二個隊伍只要姓張的成員姓名；存儲到一個新集合中。

4. 第二個隊伍篩選之后不要前2個人；存儲到一個新集合中。

5. 將兩個隊伍合并為一個隊伍；存儲到一個新集合中。

6. 根據姓名創建 Person 對象；存儲到一個新集合中。

7. 打印整個隊伍的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(“張天愛”);
two.add(“張二狗”);

    // 第一個隊伍只要名字為3個字的成員姓名；List<String> oneA = new ArrayList<>();for (String name : one) {if (name.length() == 3) {oneA.add(name);}}// 第一個隊伍篩選之后只要前3個人； List<String> oneB = new ArrayList<>();for (int i = 0; i < 3; i++) {oneB.add(oneA.get(i));}// 第二個隊伍只要姓張的成員姓名； List<String> twoA = new ArrayList<>();for (String name : two) {if (name.startsWith("張")) {twoA.add(name);}}// 第二個隊伍篩選之后不要前2個人； List<String> twoB = new ArrayList<>();for (int i = 2; i < twoA.size(); i++) {twoB.add(twoA.get(i));}// 將兩個隊伍合并為一個隊伍； List<String> totalNames = new ArrayList<>();totalNames.addAll(oneB);totalNames.addAll(twoB);// 根據姓名創建Person對象； List<Person> totalPersonList = new ArrayList<>();for (String name : totalNames) {totalPersonList.add(new Person(name));}}

}

public class Person {
private String name;

public Person() {
}public Person(String name) {this.name = 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);
// 將兩個隊伍合并為一個隊伍；
// 根據姓名創建Person對象；
// 打印整個隊伍的Person對象信息。
Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
}
}

*************************************優雅的分割線 **********************************

如果以上內容對你覺得有用,并想獲取更多的賺錢方式和免費的技術教程

請關注微信公眾號:HB荷包

一個能讓你學習技術和賺錢方法的公眾號,持續更新