1.函數式接口(掌握)

概述

有且只有一個抽象方法的接口就是函數式接口。

可以默認方法靜態方法私有方法。

舉例：

Runnable Comparator

代碼演示

package com.itheima.sh.function_inter_01;
/*
    函數式接口:
    有且只有一個抽象方法的接口就是函數式接口。
    lambda使用前提：
        1.有函數式接口
        2.某個方法的參數類型是函數式接口類型
    jdk8以後爲了驗證當前接口是一個函數式接口，增加了一個註解：
    @FunctionalInterface
    只是用來驗證當前接口是否是一個函數式接口，如果不是則報錯
 */
@FunctionalInterface
public interface Flyable {
    //定義抽象方法
    void fly();
    
    public default void test(){
        
    }
}
package com.itheima.sh.function_inter_01;

public class Test01 {
    public static void main(String[] args) {
        //調用自定義方法show
        //這裏可以使用lambda完成Flyable中的抽象方法fly
//        show(()->{ System.out.println("鳥飛了");});
    }
    //定義方法，參數是Flyable類型
    /*
        Flyable f = ()->{
            System.out.println("鳥飛了");
        }
     */
    public static void show(Flyable f){
        //使用接口對象調用fly方法
        f.fly();
    }
}

小結：

1.函數式接口：有且只有一個抽象方法的接口可以有其他方法

2.從jdk8開始爲了驗證一個接口是否是一個函數式接口我們增加了一個註解： @FunctionalInterface

3.使用lambda完成函數式接口中抽象方法

常用的函數式接口(掌握)

在jdk8後增加了幾個常用的函數式接口，最爲常見的是四個。

1.Supplier接口

1.該接口位於java.util.function 使用需要導包

2.該方法主要用來生產對象數據

3.生產方法：抽象方法：

T get() 生產數據  我們需要使用lambda完成生產數據

4.代碼演示：

練習1：

package com.itheima.sh.function_inter_02;

import java.util.function.Supplier;

/*
    需求：指定泛型是String類型，獲取String類的對象。
     Supplier<T> 生產接口
      T get() 生產數據  我們需要使用lambda完成生產數據
    使用lambda的前提：
    1.函數式接口
    2.某個方法參數類型是函數式接口類型
 */
public class Test01 {
    public static void main(String[] args) {
        //匿名內部類
        /*show(new Supplier<String>() {
            @Override
            public String get() {
                return "abc";
            }
        });*/
        //調用方法使用lambda完成   T get() 生產數據
//        show(()->{return "abc";});
        show(()->"abc");
    }
    /*
        Supplier<String> s = new Supplier<String>() {
            @Override
            public String get() {
                return "abc";
            }
        }
     */
    public static void show(Supplier<String> s){
        //調用get方法
        String str = s.get();//abc
        System.out.println("生產的對象數據是:"+str);
    }
}

練習2：

package com.itheima.sh.function_inter_02;

import java.util.function.Supplier;

/*
    需求：指定泛型是String類型，獲取String類的對象。
     Supplier<T> 生產接口
      T get() 生產數據  我們需要使用lambda完成生產數據
    使用lambda的前提：
    1.函數式接口
    2.某個方法參數類型是函數式接口類型
 */
public class Test02 {
    public static void main(String[] args) {
        
        //調用方法使用lambda完成   T get() 生產數據
//        show(()->{return "abc";});
        show(()->"abc");
        show(()->123);
        show(()->true);
    }
    //自定義泛型方法
    public static <T> void show(Supplier<T> s){
        //調用get方法
        T t = s.get();
        System.out.println("生產的對象數據是:"+t);
    }
}

小結：

1.Supplier表示生產對象的函數式接口，我們使用lambda完成抽象方法get

T get() 生產數據  我們需要使用lambda完成生產數據

2.Consumer接口

1.表示消費對象數據的接口，具體如何消費由我們使用lambda完成該函數式接口的抽象方法

void accept(T t) 對給定的參數執行此操作。

2.代碼演示

package com.itheima.sh.function_inter_02;

import java.util.function.Consumer;

/*
    Consumer<T>接口 消費接口
    void accept(T t) 對給定的參數執行此操作。
 */
public class Test03_Consumer {
    public static void main(String[] args) {
        //調用方法
       /* show((String str)->{
            //消費
            System.out.println(str);
        },"jahaha");*/
       //str表示void accept(T t) 方法形參名，屬於標識符，叫什麼都可以
//       show(str->System.out.println(str),"jahaha");
       show(str->System.out.println(str.length()),"jahaha");
    }
    //參數類型是Consumer函數式接口類型
    /*
        Consumer<String> c = (String str)->{
            //消費
            System.out.println(str);
        }

        String s = "jahaha"
     */
    private static void show(Consumer<String> c,String s) {
        //使用接口對象調用方法
        c.accept(s);
    }
}

小結：

1.Consumer屬於消費的函數式接口，需要我們使用lambda完成抽象方法：

void accept(T t) 對給定的參數執行此操作。

3.Predicate接口

1.表示判斷的函數式接口，該接口中含有一個判斷的抽象方法，我們需要使用lambda完成

boolean test(T t) 如果給定的參數t滿足判斷條件，那麼該方法返回true，不滿足返回false

2.代碼演示：

package com.itheima.sh.function_inter_02;

import java.util.function.Predicate;

/*
    判斷函數式接口：Predicate
    方法：boolean test(T t) 如果給定的參數t滿足判斷條件，那麼該方法返回true，不滿足返回false
 */
public class Test04_Predicate {
    public static void main(String[] args) {
        //調用方法
       /* show(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 4;
            }
        }, "鎖哥真帥啊");*/
       //使用lambda
//        show((String str)->{return str.length() == 4;},"鎖哥真帥啊");
        show(str->str.length() == 4,"鎖哥真帥啊");
    }
    /*
        Predicate<String> p = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 4;
            }
        }

        String s = "鎖哥真帥"

     */
    private static void show(Predicate<String> p,String s) {
        //調用方法
        boolean boo = p.test(s);
        System.out.println("boo = " + boo);
    }
}

圖解：

小結：

Predicate表示判斷接口我們使用lambda完成判斷方法：

boolean test(T t) 如果給定的參數t滿足判斷條件，那麼該方法返回true，不滿足返回false

4.Function<T,R>接口

1.該接口表示轉換接口，將前置類型T轉換爲後置類型R

2.我們需要使用lambda完成該接口中的轉換方法：

R apply(T t) 將參數T類型轉換爲R類型

3.代碼演示：

需求：將字符串"123"轉換爲整數123 —》將String類型轉換爲Integer

分析：

T類型是：String類型

R類型是：Integer

package com.itheima.sh.function_inter_02;

import java.util.function.Function;

/*
    Function<T,R>轉換接口
    R apply(T t) 將參數T類型轉換爲R類型

    需求：將字符串"123"轉換爲整數123  ---》將String類型轉換爲Integer
    分析：
    	T類型是：String類型
    	R類型是：Integer
 */
public class Test05_Function {
    public static void main(String[] args) {
        //調用方法
       /* show(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                // 需求：將字符串"123"轉換爲整數123
                return Integer.parseInt(s);
            }
        }, "123");*/

       //lambda :   R apply(T t) 將參數T類型轉換爲R類型
//        show((String str)->{return Integer.parseInt(str);},"123");
        show(str-> Integer.parseInt(str),"123");
    }

    private static void show(Function<String,Integer> f,String s) {
        //使用函數式接口對象f調用方法
        Integer i = f.apply(s);//123
        System.out.println("i = " + i);
    }
}

圖解：

小結：

1.Function<T,R>將前置類型T轉換爲後置類型R，我們使用lambda完成轉換方法：

R apply(T t) 將參數T類型轉換爲R類型

2.Stream(必須掌握)

1.介紹

1.該接口位於java.util.stream 包下，使用需要導包

2.屬於jdk8開始新的技術，表示流水線，和我們後面學習的IO流一點關係都沒有

3.數據在流水線中保存

4.代碼引入

需求：遍歷集合

package com.itheima.sh.stream_03;

import java.util.ArrayList;
import java.util.Collections;

/*
    Stream流水線引入：
        1. 首先篩選所有姓張的人；
        2. 然後篩選名字有三個字的人；
        3. 最後進行對結果進行打印輸出。
 */
public class StreamTest01 {
    public static void main(String[] args) {
        //1.創建集合對象
        ArrayList<String> list = new ArrayList<>();
        //2.添加數據
        Collections.addAll(list, "張三", "張無忌", "周芷若", "趙敏", "小昭", "張三丰", "張翠山");
        //3.創建一個新的集合保存姓張的人
        ArrayList<String> zhangList = new ArrayList<>();
        //4.遍歷list集合取出每個數據
        for (String name : list) {
            //5.判斷name是否以張開始
            if(name.startsWith("張")){
                //6.存儲到zhangList中
                zhangList.add(name);
            }
        }
//        System.out.println("zhangList = " + zhangList);
        // 2. 然後篩選名字有三個字的人；
        //7.創建集合存儲三個字的人
        ArrayList<String> shortList = new ArrayList<>();
        //8.遍歷zhangList集合
        for (String name : zhangList) {
            //9.判斷取出的數據name的長度是否是3
            if(name.length() == 3){
                shortList.add(name);
            }
        }
        // 10. 最後進行對結果進行打印輸出。
        for (String name : shortList) {
            System.out.println("name = " + name);
        }
    }
}

小結：通過上述案例我們發現使用之前的方式處理邏輯比較多的時候，遍歷集合太麻煩了，不得不創建新的集合，不得不使用for循環。

使用Stream全新的語法遍歷集合：

private static void method_2() {
        //1.創建集合對象
        ArrayList<String> list = new ArrayList<>();
        //2.添加數據
        Collections.addAll(list, "張三", "張無忌", "周芷若", "趙敏", "小昭", "張三丰", "張翠山");
        /*
                1. 首先篩選所有姓張的人；
                2. 然後篩選名字有三個字的人；
                3. 最後進行對結果進行打印輸出。
         */
        list.stream().filter(name->name.startsWith("張")).filter(name->name.length()==3).forEach(name-> System.out.println(name));
    }

2.獲取流方式

2.1使用集合獲取

將集合中的數據放到Stream流水線中。

使用Collection中的默認方法：

default Stream<E> stream() 通過集合獲取Stream流水線對象

代碼演示：

package com.itheima.sh.stream_04;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.stream.Stream;

public class Test01 {
    public static void main(String[] args) {
        //創建集合對象
        ArrayList<String> list = new ArrayList<>();
        //獲取流水線，使用Collection中的默認方法：default Stream<E> stream() 通過集合獲取Stream流水線對象
        Stream<String> stream = list.stream();


        LinkedList<Integer> list2 = new LinkedList<>();
        Stream<Integer> stream1 = list2.stream();
        
        //創建HashSet集合
        HashSet<String> hs = new HashSet<>();
        Stream<String> stream2 = hs.stream();

    }
}

2.2使用數組獲取

使用Stream流水線中的方法：

static <T> Stream<T> of(T... values) 參數是可變參數，這裏可以接收數組

代碼演示：

package com.itheima.sh.stream_04;

import java.util.stream.Stream;

/*
    將數組數據放到Stream流水線中
 */
public class Test02 {
    public static void main(String[] args) {
        //定義數組
        String[] arr = {"abc","cde","abc"};
        //將數組數據放到Stream流水線中
        //static <T> Stream<T> of(T... values) 參數是可變參數，這裏可以接收數組
        Stream<String> s1 = Stream.of(arr);
        //獲取s1流水線中的數據個數
        System.out.println(s1.count());//3

        //定義整數數組
      /*  int[] arr2 = {10,20,30};
        Stream<int[]> s2 = Stream.of(arr2);*/
        //獲取s2流水線中的數據個數
        //這裏直接將int類型的整個數組放到流水線中，如果將基本數據類型的數組放到流水線中，那麼數組一定是包裝類

//        System.out.println(s2.count());//1


        Integer[] arr3 = {10,20,30};
        Stream<Integer> s3 = Stream.of(arr3);
        System.out.println(s3.count());//3
    }
}

小結：

1.將集合中的數據放到Stream流水線中，使用Collection中的默認方法

default Stream<E> stream() 通過集合獲取Stream流水線對象

2.將數組中的數據放到流水線中使用Stream中靜態方法：

static <T> Stream<T> of(T... values) 參數是可變參數，這裏可以接收數組

注意：如果數組中的數據是基本數據類型，那麼定義的數組類型要定義爲包裝類類型。

3.常用方法

終結方法：就是返回值不再是Stream ,就不能繼續調用Stream中的方法了，就是不能鏈式編程了
非終結方法：返回值是Stream ，可以繼續調用Stream中的方法，然後繼續鏈式編程

1.forEach : 逐一處理

方法：

void forEach(Consumer<? super T> action) 對此流的每個元素執行操作。 
    參數：
    	action ： 屬於Consumer消費函數式接口類型，該接口中的消費方法：  void accept(T t);
			我們可以使用lambda
    該方法屬於終結方法，不能鏈式編程

代碼演示：

package com.itheima.sh.stream_method_05;

import java.util.function.Consumer;
import java.util.stream.Stream;

/*
    void forEach(Consumer<? super T> action) 對此流的每個元素執行操作。
    參數：
    	action ： 屬於Consumer消費函數式接口類型，該接口中的消費方法：  void accept(T t);
			我們可以使用lambda
    該方法屬於終結方法，不能鏈式編程
 */
public class StreamDemo01 {
    public static void main(String[] args) {
        //1.獲取流水線對象
        Stream<Integer> s = Stream.of(10, 20, 30, 10);
        //2.將上述流水線中的數據輸出
       /* s.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer i) {
                System.out.println(i);
            }
        });*/
//        s.forEach((Integer i)->{System.out.println(i);});
       s.forEach(i->System.out.println(i));
    }
}

小結：

forEach()方法參數Consumer類型，我們使用lambda完成accept方法

2.filter：過濾

方法：

Stream<T> filter(Predicate<? super T> predicate);
	參數：
        predicate：屬於Predicate判斷函數式接口類型，該接口中的抽象方法 boolean test(T t);
		我們在使用filter過濾方法的時候需要傳遞lambda給方法，然後進行過濾判斷，如果test(T t)方法返回	         true，說明滿足過濾條件 ，將數據放到流水線，返回false，說明不滿足條件，不放到流水線中

代碼演示：

package com.itheima.sh.stream_method_05;

import java.util.stream.Stream;

/*
    Stream<T> filter(Predicate<? super T> predicate);
	參數：
        predicate：屬於Predicate判斷函數式接口類型，該接口中的抽象方法 boolean test(T t);
		我們在使用filter過濾方法的時候需要傳遞lambda給方法，然後進行過濾判斷，如果test(T t)方法返回
		 true，說明滿足過濾條件 ，將數據放到流水線，返回false，說明不滿足條件，不放到流水線中
    注意：filter屬於非終結方法，可以實現鏈式編程
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        //1.向流水線中存儲數據
        Stream<String> s = Stream.of("abc", "abch", "defg", "kajahj");
        //2.使用s調用過濾方法篩選字符長度是4的字符串
        //boolean test(T t);
//        Stream<String> s1 = s.filter((String str) -> { return str.length() == 4;});
        //3.輸出s1中的內容  void accept(T t);
//        s1.forEach(name-> System.out.println(name));
        s.filter((String str) -> { return str.length() == 4;}).forEach(name-> System.out.println(name));
    }
}

小結：

1.Stream filter(Predicate<? super T> predicate);表示過濾方法我們需要使用lambda完成參數的函數式接口Predicate中的判斷方法 boolean test(T t);

2.使用Stream注意事項：

private static void method_2() {
        //1.向流水線中存儲數據
        Stream<String> s = Stream.of("abc", "abch", "defg", "kajahj");
        //s1流水線中的數據：abch defg
        Stream<String> s1 = s.filter((String str) -> { return str.length() == 4;});
        s1.forEach(name-> System.out.println(name));

        //查看s中的數據
        //java.lang.IllegalStateException: stream has already been operated upon or closed
        /*
            流水線對象只能消費一次(操作一次)，不能操作多次，否則就會報異常，流水線關閉異常
         */
        s.forEach(str-> System.out.println(str));
    }

小結：一個流水線對象只能消費一次。

3.count：統計個數

long count(); 終結方法(不能鏈式編程) 表示統計流水線中的數據個數

//1.創建流水線對象
Stream<String> s = Stream.of("abc", "akja", "alala");
//求個數
long count = s.count();
System.out.println("count = " + count);

4.limit：取用前幾個

Stream<T> limit(long n):獲取Stream流對象中的前n個元素,返回一個新的Stream流對象.屬於非終結方法，可以鏈式編程

 //1.創建流水線對象
Stream<String> s = Stream.of("abc", "akja", "alala");
//Stream<T> limit(long n):獲取Stream流對象中的前n個元素,返回一個新的Stream流對象.屬於非終結方法，可以鏈式編程
//2表示獲取流水線中的前2個數據
s.limit(2).forEach(str-> System.out.println(str));//"abc", "akja"

5.skip：跳過前幾個

Stream<T> skip(long n): 跳過Stream流對象中的前n個元素,返回一個新的Stream流對象.屬於非終結方法，可以鏈式編程

代碼演示：

//1.創建流水線對象
 Stream<String> s = Stream.of("abc", "akja", "alala");

 //Stream<T> skip(long n): 跳過Stream流對象中的前n個元素,返回一個新的Stream流對象.屬於非終結方法，可以鏈式編程
//跳過前2個元素 獲取數據 "alala"
//這裏的2表示跳過前2個元素
s.skip(2).forEach(str-> System.out.println("str = " + str));

6.映射：map

<R> Stream<R> map(Function<? super T, ? extends R> mapper);表示映射方法，將T類型轉換爲R類型，參數屬於Function類型，屬於函數式接口，轉換方法：R apply(T t) 我們使用lambda完成轉換

將原來的T類型圓轉換爲R類型及菱形。

需求：使用映射方法將老流中的字符串數據轉換爲新流中的整數。

package com.itheima.sh.stream_method_05;

import java.util.stream.Stream;

public class StreamDemo04 {
    public static void main(String[] args) {
        //1.創建老流
        Stream<String> oldStream = Stream.of("123", "345", "456");
        //2.通過map方法將上述老流中的數據映射爲新的類型數據
        /*
            <R> Stream<R> map(Function<? super T, ? extends R> mapper);表示映射方法，將T類型轉換爲R類型，參數屬於Function類型，
            屬於函數式接口，轉換方法：R apply(T t) 我們使用lambda完成轉換
         */
        Stream<Integer> newStream = oldStream.map(str -> {
            return Integer.parseInt(str);
        });
        //查看新的流水線中的數據
        newStream.forEach(i-> System.out.println(i));
    }
}

小結：

1.map方法表示映射方法，我們可以將T類型轉換爲R類型，使用lambda完成Function中的apply方法

7.concat：組合

static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b): 把參數列表中的兩個Stream流對象a和b,合併成一個新的Stream流對象
    在新的流水線中，a流的數據位於前面

代碼演示：

package com.itheima.sh.stream_method_05;

import java.util.stream.Stream;

public class StreamDemo05 {
    public static void main(String[] args) {
        Stream<String> a = Stream.of("123", "345", "456");
        Stream<String> b = Stream.of("柳巖", "楊冪", "冰冰");
        //將上述a和b流中的數據拼接到一個新的流中
        /*
            static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b):
            把參數列表中的兩個Stream流對象a和b,合併成一個新的Stream流對象
            在新的流水線中，a流的數據位於前面
         */
        Stream<String> c = Stream.concat(a, b);
        c.forEach(s -> System.out.println(s));
    }
}

4.綜合練習(課下必須完成)

package com.itheima.sh.stream_method_05;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

/*
    現在有兩個`ArrayList`集合存儲隊伍當中的多個成員姓名，要求使用Stream**依次**進行以下若干操作步驟：
    1. 第一個隊伍只要名字爲3個字的成員姓名；
    2. 第一個隊伍篩選之後只要前3個人；
    3. 第二個隊伍只要姓張的成員姓名；
    4. 第二個隊伍篩選之後不要前2個人；
    5. 將兩個隊伍合併爲一個隊伍；
    6. 根據姓名創建`Person`對象；
    7. 打印整個隊伍的Person對象信息。
 */
public class Test01 {
    public static void main(String[] args) {
        List<String> one = new ArrayList<>();
        one.add("迪麗熱巴");
        one.add("宋遠橋");
        one.add("蘇星河");
        one.add("老子");
        one.add("莊子");
        one.add("孫子");
        one.add("洪七公");
        one.add("宋小寶");

        // 1. 第一個隊伍只要名字爲3個字的成員姓名；
        // 2. 第一個隊伍篩選之後只要前3個人； boolean test(T t);
        //one.stream().filter(str->str.length()==3)篩選的數據：宋遠橋 蘇星河 洪七公 宋小寶
        //最後結果：宋遠橋 蘇星河 洪七公
        Stream<String> oneStream = one.stream().filter(str -> str.length() == 3).limit(3);


        List<String> two = new ArrayList<>();
        two.add("古力娜扎");
        two.add("張無忌");
        two.add("張三丰");
        two.add("趙麗穎");
        two.add("張二狗");
        two.add("張天愛");
        two.add("張三");
        //  3. 第二個隊伍只要姓張的成員姓名； boolean test(T t);
        //  4. 第二個隊伍篩選之後不要前2個人；
        //two.stream().filter(name->name.startsWith("張")) 張無忌 張三丰 張二狗 張天愛 張三
        //最後結果：張二狗 張天愛 張三
        Stream<String> twoStream = two.stream().filter(name -> name.startsWith("張")).skip(2);
        // 5. 將兩個隊伍合併爲一個隊伍；
        // 6. 根據姓名創建`Person`對象；
        // 7. 打印整個隊伍的Person對象信息。
        //Stream.concat(oneStream,twoStream) 結果是：宋遠橋 蘇星河 洪七公  張二狗 張天愛 張三
//        Stream<String> concat = Stream.concat(oneStream, twoStream);
        //6. 根據姓名創建`Person`對象； 是將流水線中的String類型轉換爲Person類型
        //R apply(T t);
        /*Stream.concat(oneStream, twoStream).map((String name) -> {
            Person p = new Person(name);
            return p;
        });*/
        //void accept(T t);
        Stream.concat(oneStream, twoStream).map(name->new Person(name)).forEach(person-> System.out.println(person));
    }
}

5.收集Stream結果(理解)

我們之前學習瞭如何將集合和數組中的數據放到Stream流水線中，那麼使用Stream流水線操作數據很方便，最後操作完畢之後如果想將流水線中數據在放回集合或者數組中，怎麼辦呢？

1.將流水線中的數據放回到集合中

收集方法：使用Stream流水線中的方法：

R collect(Collector  collector) 收集方法
    	參數：collector屬於Collector接口類型，表示收集器。接口不能創建對象，我們使用工具類Collectors來獲取收集器接口的對象
    收集方法：
    1）static <T> Collector toList() 返回一個 Collector ，將輸入元素累加到一個新的 List 。 
    2）static <T> Collector toSet() 返回一個 Collector ，將輸入元素累加到一個新的 Set 。

代碼演示：

package com.itheima.sh.stream_collect_06;

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/*
    R collect(Collector  collector) 收集方法
    	參數：collector屬於Collector接口類型，表示收集器。接口不能創建對象，我們使用工具類Collectors來獲取收集器接口的對象
    收集方法：
    1）static <T> Collector toList() 返回一個 Collector ，將輸入元素累加到一個新的 List 。
    2）static <T> Collector toSet() 返回一個 Collector ，將輸入元素累加到一個新的 Set 。
 */
public class Demo01 {
    public static void main(String[] args) {
        //1.獲取Stream對象
        Stream<Integer> s = Stream.of(123, 345, 567);
        //2.將s中的數據收集到List中
//        List<Integer> list = s.collect(Collectors.toList());
//        System.out.println("list = " + list);//list = [123, 345, 567]

        //3.放到Set中
        Set<Integer> set = s.collect(Collectors.toSet());
        System.out.println("set = " + set);//set = [567, 345, 123]
    }
}

小結：

將Stream中中數據收集到集合中步驟：

1.使用Stream中的方法：

 R collect(Collector  collector) 收集方法

2.使用工具類獲取收集器即Collector對象

 1）static <T> Collector toList() 返回一個 Collector ，將輸入元素累加到一個新的 List 。
 2）static <T> Collector toSet() 返回一個 Collector ，將輸入元素累加到一個新的 Set 。

2.收集到數組中

Stream中的方法：

Object[] toArray();

代碼演示：

package com.itheima.sh.stream_collect_06;

import java.util.Arrays;
import java.util.stream.Stream;
/*
    Object[] toArray();
 */
public class Demo02 {
    public static void main(String[] args) {
        //1.創建Stream對象
        Stream<Integer> s = Stream.of(123, 345, 567);
        //2.放到數組中
        Object[] arr = s.toArray();
        System.out.println(Arrays.toString(arr));//[123, 345, 567]
    }
}

3.Vector集合

1.屬於List集合下面的子類，從jdk1.0就有了，從jdk1.2開始被ArrayList集合取代了。Vector多線程安全的，但是效率低

2.構造方法：

Vector()  構造一個空向量，使其內部數據數組的大小爲 10，其標準容量增量爲零。

3.代碼演示：

package com.itheima.sh.vector_07;

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorDemo01 {
    public static void main(String[] args) {
        method_2();

    }
    /*
        Iterator 屬於jdk1.2的，但是Vector集合屬於jdk1.0的，那麼在1.2之前怎麼迭代Vector集合啊？
            使用最早的迭代器Enumeration：
        1. Enumeration<E>最早的迭代器接口
        2.從jdk1.2後我們建議使用Iterator迭代器接口，而不是Enumeration，因爲Iterator中多了一個remove刪除方法
        並且Iterator接口中的方法名字比Enumeration中的方法名字短：
            boolean hasMoreElements() 測試此枚舉是否包含更多的元素  相當於Iterator接口中的hasNext()
             E nextElement() 獲取迭代器數據  相當於Iterator接口中的next()
     */
    private static void method_2() {
        //1.創建Vector集合對象
        Vector<String> v = new Vector<>();
        //2.添加數據
        v.add("柳巖");
        v.add("大鵬");
        v.add("小嶽嶽");
        v.add("柳巖");
        //3.根據集合對象調用方法獲取Enumeration迭代器
        //Enumeration<E> elements()返回此向量的組件的枚舉。
        Enumeration<String> en = v.elements();
        while(en.hasMoreElements()){
            //獲取數據
            String s = en.nextElement();
            System.out.println("s = " + s);
        }

    }

    private static void method_1() {
        //1.創建Vector集合對象
        Vector<String> v = new Vector<>();
        //2.添加數據
        v.add("柳巖");
        v.add("大鵬");
        v.add("小嶽嶽");
        v.add("柳巖");
        //3.迭代集合
        //獲取迭代器 可以使用Iterator迭代器迭代
        Iterator<String> it = v.iterator();
        while(it.hasNext()){
            //獲取數據
            String s = it.next();
            System.out.println("s = " + s);
        }
    }
}

day19【函數式接口、Stream、Vector集合】課上

1.函數式接口(掌握)

概述

代碼演示

常用的函數式接口(掌握)

1.Supplier接口

2.Consumer接口

3.Predicate接口

4.Function<T,R>接口

2.Stream(必須掌握)

1.介紹

2.獲取流方式

2.1使用集合獲取

2.2使用數組獲取

3.常用方法

1.forEach : 逐一處理

2.filter：過濾

3.count：統計個數

4.limit：取用前幾個

5.skip：跳過前幾個

6.映射：map

7.concat：組合

4.綜合練習(課下必須完成)

5.收集Stream結果(理解)

1.將流水線中的數據放回到集合中

2.收集到數組中

3.Vector集合