1. 接口中的實(shí)現(xiàn)方法

① 使用 default 關(guān)鍵字就可以給接口增加一個(gè)非抽象的方法實(shí)現(xiàn)；
② 接口還可以存在 static 靜態(tài)方法實(shí)現(xiàn)，使用 接口名.靜態(tài)方法名 的形式直接調(diào)用；

包括聲明@FunctionalInterface限制接口只有1個(gè)抽象方法時(shí)，也可以增加①或②。

代碼示例：

public class TestInterface {
      public static void main(String[] args) {
            TestInter ti = new TestInter() {
                  @Override
                  public void m1() {
                        System.out.println("m1():匿名內(nèi)部類實(shí)現(xiàn)該接口，只需要覆蓋m1()");
                  }
            };
            
            ti.m1();
            ti.m2();
            TestInter.m3();
      }
}
/**
* 接口
* 測(cè)試Java8新特性，default和static在接口中定義的場(chǎng)景
* @FunctionalInterface 聲明為函數(shù)式接口，只能有 1 個(gè)公開(kāi)抽象方法
*/
@FunctionalInterface
interface TestInter {
      void m1(); // 公開(kāi)抽象方法
      default void m2() {
            System.out.println("m2():default修飾的方法實(shí)現(xiàn)，在接口中...");
      }
      public static void m3() {
            System.out.println("m3():static修飾的方法實(shí)現(xiàn)，在接口中...");
      }
}

2. Lambda 表達(dá)式

概念：允許把函數(shù)作為一個(gè)方法的參數(shù)，代碼簡(jiǎn)潔緊湊（函數(shù)作為參數(shù)傳遞到方法中）
語(yǔ)法：

函數(shù)式接口 變量名 = (參數(shù)1,參數(shù)2...)->{
    //方法體
};

新的操作符：-> （箭頭操作符）

• 箭頭操作符左側(cè) (參數(shù)1,參數(shù)2,...)-> 表示參數(shù)列表
• 箭頭操作符右側(cè) ->{...} 表示方法體

Lambda 表達(dá)式特點(diǎn)：

• 形參列表的數(shù)據(jù)類型會(huì)自動(dòng)推斷
• 如果形參列表為空，只需保留()
• 如果形參列表只有1個(gè)參數(shù)，可以省略()，只要參數(shù)名字即可
• 如果執(zhí)行語(yǔ)句只有1句，且無(wú)返回值，{}可以省略
• 若有返回值，仍想省略{}，return也省略，必須保證執(zhí)行語(yǔ)句為1句
• Lambda表達(dá)式不會(huì)生成單獨(dú)的內(nèi)部類.class文件
• Lambda表達(dá)式訪問(wèn)局部變量時(shí)，變量要修飾為 final，如果沒(méi)加會(huì)隱式自動(dòng)添加

示例代碼：

public class TestBasicLambda {
      public static void main(String[] args) {
            // 普通方式
            List<String> list1 = Arrays.asList("aaa", "ddd", "ccc",  "bbb");
            list1.sort(new Comparator<String>() {
                  @Override // 按首字符排序規(guī)則
                  public int compare(String o1, String o2) {
                        return o1.charAt(0) > o2.charAt(0) ? 1 : -1;
                  }
            });
            System.out.println(list1); // aaa bbb ccc ddd
            
            // Lambda表達(dá)式方式：實(shí)現(xiàn)接口中唯一1個(gè)方法的匿名內(nèi)部類
            List<String> list2 = Arrays.asList("aaa", "ddd", "ccc",  "bbb");
            list2.sort( (s1, s2)->{ return s1.charAt(0)>s2.charAt(0) ?  1 : -1; });
            System.out.println(list2); // aaa bbb ccc ddd
      }
}

3. 方法引用 ::

Lambda表達(dá)式的一種簡(jiǎn)寫(xiě)形式。
如果Lambda表達(dá)式方法體中只是調(diào)用一個(gè)特定的已存在的方法，則可以使用方法引用。
使用 :: 操作符將對(duì)象或類和方法的名字分割開(kāi)，有 4 種形式：
① 對(duì)象::實(shí)例方法
② 類::靜態(tài)方法
③ 類::實(shí)例方法
④ 類::new
注意：調(diào)用的方法的參數(shù)列表與返回值類型，都與函數(shù)式接口中的方法參數(shù)列表與返回值類型一致。

代碼示例（使用到了函數(shù)式編程的 4 個(gè)核心接口）：

public class TestMethodRef {
    public static void main(String[] args) {
        // Lambda表達(dá)式簡(jiǎn)化了匿名內(nèi)部類，方法引用簡(jiǎn)化了Lambda表達(dá)式
        // 1.對(duì)象::方法名
        Consumer<String> con = (s)->System.out.println(s); // lambda
        con.accept("hello,world"); // hello,world
        Consumer<String> con2 = System.out::println; // 方法引用
        con2.accept("哈哈哈"); // 哈哈哈
        
        // String也可以是自定義類
        String s = new String("hello,world");
        //Supplier<Integer> sup = ()->s.length(); // lambda
        Supplier<Integer> sup = s::length; // 方法引用
        System.out.println(sup.get()); // 11
        
        // 2.類名::靜態(tài)方法(不常用)
        //Comparator<Integer> com = (x,y)->Integer.compare(x,y); // lambda
        Comparator<Integer> com = Integer::compare; // 方法引用
        System.out.println( com.compare(1, 2) ); // -1: 1 < 2
        
        TreeSet<Integer> ts = new TreeSet<Integer>(com);
        System.out.println(ts); // ts就會(huì)遵循com指向的 Integer中的Compare方法進(jìn)行排序
        
        // 3.類名::實(shí)例方法名
        //Function<String, Integer> fun = s->s.hashCode(); // lambda
        Function<String, Integer> fun = String::hashCode; // 方法引用
        Integer hash = fun.apply(s);
        System.out.println(hash); // 2137655864
        
        // 4.類::new 即 類名::構(gòu)造方法
        //Supplier<String> supp = ()->new String(); // lambda
        Supplier<String> supp = String::new; // 方法引用
        System.out.println(supp.get().getClass()); // class java.lang.String
    }
}

4. 函數(shù)式接口 × 4

函數(shù)式編程：函數(shù)的參數(shù)也是函數(shù)，函數(shù)返回的也是函數(shù)。

概念：如果一個(gè)接口只有 1 個(gè)公開(kāi)抽象方法，則該接口為函數(shù)式接口。

• 為了確保接口達(dá)到只有1個(gè)方法的要求，接口名上添加注解 @FunctionalInterface
• Java8內(nèi)置 4 個(gè)核心函數(shù)式接口interface。
  位置：java.util.function

public class TestMethodInterface {
      public static void main(String[] args) {
            // 接口引用 指向 Lambda表達(dá)式的匿名內(nèi)部類對(duì)象
            Interface t = ()->System.out.println("函數(shù)式編程...");
            t.m(); // 函數(shù)式編程...
      }
}

@FunctionalInterface
interface Interface {
      void m();
}

① Predicate 接口（斷言、返回真假）

根據(jù)賦值的Lambda表達(dá)式邏輯，用作一個(gè)參數(shù)的斷言（布爾值函數(shù)）
成員方法：

boolean test(T t)
在給定的參數(shù)上執(zhí)行這個(gè)斷言邏輯。
default Predicate<T> and(Predicate<? super T> other)
返回一個(gè)組合的斷言，表示該斷言與另一個(gè)斷言的短路邏輯AND。
static <T> Predicate<T> isEqual(Object targetRef)
返回根據(jù) Objects.equals(Object, Object)測(cè)試兩個(gè)參數(shù)是否相等的 斷言 。
default Predicate<T> negate()
返回表示此斷言的邏輯否定的斷言。
default Predicate<T> or(Predicate<? super T> other)
返回一個(gè)組合的斷言，表示該斷言與另一個(gè)斷言的短路邏輯或。

基本使用：

Predicate<String> p1 = str -> str.length() == 9; // 字符串長(zhǎng)度是否等于9
Predicate<String> p2 = str -> str.startsWith("j"); // 是否以j開(kāi)頭
Predicate<String> p3 = p1.and(p2); // 字符串是否長(zhǎng)度為9并且以j開(kāi)頭
Predicate<String> p4 = p1.or(p2); // 字符串是否長(zhǎng)度為9或者以j開(kāi)頭
Predicate<String> p5 = p1.negate(); // 字符串長(zhǎng)度是否不等于9
Predicate<String> p6 = Predicate.isEqual("Java"); // 字符串是否等于Java
System.out.println(p1.test("aaa")); // false
System.out.println(p2.test("java")); // true
System.out.println(p3.test("jjjaaabbb"));// true
System.out.println(p4.test("ja"));// true
System.out.println(p5.test("123456789"));// false
System.out.println(p6.test("java"));// false 

函數(shù)傳參：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class TestPredicate {
      public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            list.add("zhangsan");
            list.add("lisi");
            list.add("wangwu");
            list.add("zhaoliu");
            list.add("zhangqi");
            
            // Predicate斷言：過(guò)濾出來(lái)已zhang開(kāi)頭的元素
            List<String> ls = filter(list, (s)->s.startsWith("zhang"));
            for (String string : ls) {
                  System.out.print(string + " "); // zhangsan zhangqi
            }
      }
      
      public static List<String> filter(List<String> list,  Predicate<String> p) {
            List<String> l = new ArrayList<String>();
            for (String s : list) {
                  if (p.test(s)) {
                        l.add(s);
                  }
            }
            return l;
      }
}

② Consumer 接口（消費(fèi)、有去無(wú)回）

根據(jù)賦值的Lambda表達(dá)式邏輯，接受單個(gè)輸入?yún)?shù)并且不返回結(jié)果的操作。
成員方法：

void accept(T t)
對(duì)給定的參數(shù)執(zhí)行此操作。
default Consumer<T> andThen(Consumer<? super T> after)
返回一個(gè)組合的 Consumer ，按順序執(zhí)行該操作，然后執(zhí)行 after操作。

基本使用：

// 消費(fèi)：給其內(nèi)容，不關(guān)心其作何使用，沒(méi)有返回值
Consumer<String> c = s->System.out.println(s);;
c.accept("hello world!"); // hello world!
// andThen后執(zhí)行
c.andThen(s->System.out.println("hello," + s)).accept("world"); // world hello,world

函數(shù)傳參：

import java.util.function.Consumer;
public class TestConsumer {
      public static void main(String[] args) {
            m1(100, (a)->System.out.println("今天掙錢了：" + a)); // 今天掙了100
            
            m2(10, (a)->{
                  for (int i = 0; i < 10; i++) {
                        System.out.println(i);
                  }
            }); // 0 1 2 3 4 5 6 7 8 9
      }
      public static void m1(double money, Consumer<Double> consumer)  {
            consumer.accept(money);
      }
      public static void m2(int num, Consumer<Integer> consumer) {
            consumer.accept(num);
      }
}

③ Supplier 接口（創(chuàng)造、無(wú)中生有）

根據(jù)賦值的Lambda表達(dá)式邏輯，根據(jù)只有1個(gè)抽象方法T get()，沒(méi)有參數(shù)，返回一個(gè)T類型的結(jié)果。
成員方法：

T get()
獲得結(jié)果。

基本使用：

Supplier<Double> sup = ()->new Double(Math.random());
System.out.println( sup.get() ); // 輸出1個(gè)隨機(jī)<1的小數(shù)

函數(shù)傳參：

import java.util.Random;
import java.util.function.Supplier;
public class TestSupplier {
      public static void main(String[] args) {
            int result = getSum(10, ()->new Random().nextInt(100));
            System.out.println(result); // 10個(gè)100以內(nèi)隨機(jī)整數(shù)的和
            
            Supplier<Integer> sup = ()->{
                  int sum = 0;
                  for (int i = 0; i <= 100; i++) {
                        sum += i;
                  }
                  return sum;
            };
            System.out.println("1-100的和：" + sup.get()); // 5050
      }
      
      public static int getSum(int num, Supplier<Integer> supplier) {
            int sum = 0;
            for (int i = 0; i <= num; i++) {
                  sum += supplier.get();
            }
            return sum;
      }
}

④ Function 接口（傳遞、返回?cái)?shù)據(jù)）

根據(jù)賦值的Lambda表達(dá)式邏輯，計(jì)算T類型的值，返回R類型的值。
成員方法：

R apply(T t)
將此函數(shù)應(yīng)用于給定的參數(shù)。
default <V> Function<T,V> andThen(Function<? super R,? extends V> after)
返回一個(gè)組合函數(shù)，首先將該函數(shù)應(yīng)用于其輸入，然后將 after函數(shù)應(yīng)用于結(jié)果。
default <V> Function<V,R> compose(Function<? super V,? extends T> before)
返回一個(gè)組合函數(shù)，首先將 before函數(shù)應(yīng)用于其輸入，然后將此函數(shù)應(yīng)用于結(jié)果。
static <T> Function<T,T> identity()
返回一個(gè)總是返回其輸入?yún)?shù)的函數(shù)。

基本使用：

// String 為傳入 Lambda 表達(dá)式參數(shù)的類型T，Integer 為返回值的類型R
Function<String, Integer> up1 = (s)->s.length();
System.out.println( up1.apply("hello") ); // 5
// 將 up1 的 lambda 運(yùn)行后，作為結(jié)果再執(zhí)行 up2，組合在一起
Function<String, String> up2 = (s)->"aaa" + s;
System.out.println( up1.compose(up2).apply("12345") ); // 3+5==8
// 將 up2 的 lambda 運(yùn)行后，作為結(jié)果然后再執(zhí)行 apply
Function<String, String> up3 = (s)->"bbb" + s;
System.out.println( up3.andThen(up2).apply("11111") ); // aaabbb11111
// identity() 靜態(tài)方法，總是返回其輸入的參數(shù)
Function<String, String> up4 = Function.identity();
System.out.println( up4.apply("Jerry") );

函數(shù)傳參：

import java.util.function.Function;
public class TestFunction {
      public static void main(String[] args) {
            String up = stringUpper("hello,world",  (s)->s.toUpperCase());
            System.out.println(up); // HELLO,WORLD
      }
      
      public static String stringUpper(String s, Function<String,  String> fun) {
            return fun.apply(s);
      }
}

5. Stream (流)接口 API

Stream 接口: 支持對(duì)一系列元素進(jìn)行順序和并行的聚合操作功能接口，是Java8中處理數(shù)組、集合的抽象概念。

• 可以執(zhí)行非常復(fù)雜的查找、過(guò)濾、映射等操作。

public interface Stream<T>
    extends BaseStream<T,Stream<T>>

5.1 stream 基本操作

public class TestStream {
      public static void main(String[] args) {
            // Stream --> 數(shù)組、集合
            List<String> list = Arrays.asList("zhangsan", "lisi",  "wangwu", "zhaoliu", "lucy");
            
            // Stream 中存儲(chǔ)的是數(shù)據(jù)的操作，自身不保存數(shù)據(jù)。
            // 1.創(chuàng)建 Stream
            Stream<String> stream = list.stream();
            // 2.中間操作
            Stream<String> center = stream.filter((s)->s.length()>=5);
            // 3.最終操作
            System.out.println("名字長(zhǎng)度>=5的是：");
            center.forEach(System.out::println);
            
            // 一行套娃版：
            System.out.println();
            list.stream().filter(s->s.length()>=5).forEach(System.out::println);
      }
}
// zhangsan wangwu zhaoliu

5.2 stream 中間操作

常用API： filter limit distinct map sorted

Stream<T> filter(Predicate<? super T> predicate)
返回由與此給定謂詞匹配的此流的元素組成的流。

Stream<T> limit(long maxSize)
返回由此流的元素組成的流，截短長(zhǎng)度不能超過(guò) maxSize 。

Stream<T> distinct()
返回由該流的不同元素（根據(jù) Object.equals(Object) ）組成的流。

<R> Stream<R> map(Function<? super T,? extends R> mapper)
返回由給定函數(shù)應(yīng)用于此流的元素的結(jié)果組成的流。

Stream<T> sorted()
返回由此流的元素組成的流，根據(jù)自然順序排序。

Stream<T> sorted(Comparator<? super T> comparator)
返回由該流的元素組成的流，根據(jù)提供的 Comparator進(jìn)行排序。

中間操作示例：

public class TestStreamAPI {
      public static void main(String[] args) {
            List<String> list = Arrays.asList("zhangsan", "lisi",  "wangwu", "zhaoliu", "zuee", "zhangsan");
            
            // filter：過(guò)濾，指定規(guī)則
            System.out.println("--------------filter---------------");
            list.stream().filter(s->s.startsWith("z")).filter(s->s.contains("an")).forEach(System.out::println); // zhangsan ×2
            
            // limit：截?cái)?，返回不超過(guò)指定數(shù)量
            System.out.println("--------------limit---------------");
            list.stream().limit(2).forEach(System.out::println); //  zhangsan lisi
            // distinct：篩選，利用 hashCode 和 equals，不會(huì)影響原數(shù)據(jù)
            System.out.println("--------------distinct---------------");
            List<String> ls = new ArrayList<String>();
            list.stream().distinct().forEach(s->ls.add(s));
            ls.stream().forEach(System.out::println); // 過(guò)濾掉了重復(fù)的1個(gè) zhangsan
            
            // map：給到T返回R，自動(dòng)推斷類型。不是集合！不是集合！不是集合！
            System.out.println("--------------map---------------");
            list.stream().map(s->s.toUpperCase()).forEach(System.out::println); //  全轉(zhuǎn)大寫(xiě)
            list.stream().map(String::toUpperCase).forEach(System.out::println); //  全轉(zhuǎn)大寫(xiě)(方法引用)
            
            // sorted：自然排序，默認(rèn)升序(基本類型直接排序，引用類型需要實(shí)現(xiàn) Comparable 接口中的 compareTo)
            System.out.println("--------------sorted---------------");
            list.stream().sorted().forEach(System.out::println);
            System.out.println("--------------sorted()---------------");
            // sorted(Comparator<? super T> comparator)：定制排序
            list.stream().sorted((x,y)->x.charAt(0) -  y.charAt(0)).forEach(System.out::println); // 實(shí)現(xiàn) Comparable 接口的匿名內(nèi)部類
            
      }
}

5.3 stream 終止操作

常用API： count forEach anyMatch allMatch noneMatch findFirst findAny min max

long count()
返回流中的元素個(gè)數(shù)。

void forEach(Consumer<? super T> action)
對(duì)此流的每個(gè)元素執(zhí)行遍歷操作。

boolean anyMatch(Predicate<? super T> predicate)
或，流中是否有包含指定規(guī)則的元素

boolean allMatch(Predicate<? super T> predicate)
且，流中是否全部包含指定規(guī)則的元素

boolean noneMatch(Predicate<? super T> predicate)
非，流中是否都不包含指定規(guī)則的元素

Optional<T> findFirst()
返回流的第一個(gè)元素的Optional，如果流為空，則返回一個(gè)空的Optional 。

Optional<T> findAny()
返回流的任意一個(gè)隨機(jī)元素的Optional，如果流為空，則返回一個(gè)空的Optional 。

Optional<T> max(Comparator<? super T> comparator)
根據(jù)提供的 Comparator 返回此流的最大元素。

Optional<T> min(Comparator<? super T> comparator)
根據(jù)提供的 Comparator 返回此流的最小元素。

終止操作示例：

public class TestStreamEnd {
      public static void main(String[] args) {
            List<String> list = Arrays.asList("changsan", "lisi",  "wangwu", "zhaoliu", "zuee");
            
            // 1.forEach: 遍歷
            list.stream().forEach(System.out::println); // changsan  lisi wangwu zhaoliu zuee
            
            // 2.count: 流中元素的個(gè)數(shù)
            long count = list.stream().filter(s->s.length()>4).count();
            System.out.println("流中長(zhǎng)度>4元素個(gè)數(shù)：" + count); // 3
            
            // 3.anymatch: 或，是否有包含的元素
            boolean bool1 =  list.stream().filter(s->s.length()>4).anyMatch(s->s.startsWith("w"));
            System.out.println("流中是否是有包含 w 開(kāi)頭的元素：" +  bool1); // true
            
            // 4.allmatch: 且，是否全部都包含的元素
            boolean bool2 =  list.stream().filter(s->s.length()>4).allMatch(s->s.startsWith("w"));
            System.out.println("流中是否全是包含 w 開(kāi)頭的元素：" +  bool2); // false
            // 5.noneMatch: 非，是否沒(méi)有匹配的元素
            boolean bool3 =  list.stream().filter(s->s.length()>4).noneMatch(s->s.startsWith("a"));
            System.out.println("流中是否沒(méi)有包含 a 開(kāi)頭的元素：" +  bool3); // true
            
            // 6.findFirst: 返回流中第一個(gè)元素
            String s1 =  list.stream().filter(s->s.length()>4).findFirst().get();
            System.out.println("流中的第一個(gè)元素是：" + s1); //  changsan
            
            // 7.findAny: 返回流中任意一個(gè)元素
            String s2 = list.stream().findAny().get();
            String s3 = list.parallelStream().findAny().get(); // 并行流
            System.out.println("流中的隨機(jī)1個(gè)元素是：" + s2 + " " +  s3); // changsan wangwu
            
            // 8.max/min: 返回流中的一個(gè)最大/最小的元素，需要在max/min中指定 Comparable 接口的比較規(guī)則
            String max = list.stream().max((e1,  e2)->e1.charAt(0)-e2.charAt(0)).get();
            System.out.println("首字母最大的是：" + max); // zhaoliu
      }
}

串行與并行的 Stream 效率對(duì)比：

public class TestStreamOther {
      public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            
            for (int i = 0; i < 1000000; i++) {
                  list.add(UUID.randomUUID().toString());
            }
            
            // stream串行：一條執(zhí)行路徑，單線程
            System.out.println("串行運(yùn)行時(shí)間：");
            long start = System.currentTimeMillis();
            long count = list.stream().sorted().count();
            System.out.println("排序的元素?cái)?shù)量：" + count);
            System.out.println("用時(shí)：" + (System.currentTimeMillis() -  start)); // ≈1050毫秒
            // parallelStream 并行：多條執(zhí)行路徑，多線程
            System.out.println("并行運(yùn)行時(shí)間：");
            start = System.currentTimeMillis();
            count = list.parallelStream().sorted().count();
            System.out.println("排序的元素?cái)?shù)量：" + count);
            System.out.println("用時(shí)：" + (System.currentTimeMillis() -  start)); // ≈520毫秒
      }
}