常用函数式接口，Stream流

01.第一章：常用函数式接口_Predicate判断接口：

1).java.util.Function.Prdedicate(函数式接口):
2).抽象方法：
    1).boolean test(T t)
3).默认方法：
    1).and():用于计算两个条件的并且关系；
    2).or():两个条件的或者关系；
    3).negate():非(取反)
4).示例代码：
public class Demo {
public static void main(String[] args) {
    //1.抽象方法：boolean test(T t):测试
    m1((s) -> s.length() >= 5, "ello");
    Predicate p;

    //2.默认方法：and():两个条件的并且关系
    //需求：判断一个字符串中是否即包含大写的H又包含大写的W
    m2((s) -> s.contains("H"), (s) -> s.contains("W"), "Helloworld");

    //3.默认方法：or():两个条件的或者关系
    //需求：判断一个字符串中是否即包含大写的H《或者》包含大写的W
    m3((s) -> s.contains("H"), (s) -> s.contains("W"), "helloworld");

    //4.默认方法：negate():非
    //需求：判断字符串中是否不包含大写的H
    m4((s) -> s.contains("H"), "jello");
}

//1.抽象方法：boolean test(T t):测试
public static void m1(Predicate<String> p,String str){
    boolean b = p.test(str);
    System.out.println("字符串 " + str + " 的长度是否很长：" + (b ? "很长" : "不长"));
}

//2.默认方法：and():两个条件的并且关系
//需求：判断一个字符串中是否即包含大写的H又包含大写的W
public static void m2(Predicate<String> p1, Predicate<String> p2, String string) {
    boolean b = p1.and(p2).test(string);
    System.out.println("字符串：" + string + " 是否即包含大写的H又包含大写的W :" + b);
}

//3.默认方法：or():两个条件的或者关系
//需求：判断一个字符串中是否即包含大写的H《或者》包含大写的W
public static void m3(Predicate<String> p1, Predicate<String> p2, String s) {
    boolean b = p1.or(p2).test(s);
    System.out.println("字符串：" + s + " 是否即包含大写的H《或者》包含大写的W : " + b);
}

//4.默认方法：negate():非
//需求：判断字符串中是否不包含大写的H
public static void m4(Predicate<String> p1, String s) {
    boolean b = p1.negate().test(s);
    System.out.println("字符串：" + s + " 是否不包含大写的H : " + b);

}
}

02.第一章：常用函数式接口Predicate判断接口练习：

1).有如下集合：
String[ ] array = { "迪丽热巴, 女", "古力娜扎, 女", "马尔扎哈, 男", "赵丽颖, 女" };
要求：将符合条件的字符串筛选到集合中：
1 .必须为女生；
2 . 姓名为4个字。
     2).示例代码：
public class Demo {
public static void main(String[] args) {
    String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,女", "赵丽颖,女" };
    /*
        要求：将符合条件的字符串筛选到集合中：
        1 .必须为女生；
        2 . 姓名为4个字。

     */
    List<String> list = new ArrayList<>();
    for (String s : array) {//"迪丽热巴,女"
        boolean b = checkStr((str)->str.split(",")[0].length() == 4,
                                (str)->str.split(",")[1].equals("女"),
                                s);
        if (b == true) {
            list.add(s);
        }
    }
    System.out.println(list);

}
//此方法用于测试每个字符串，如果符合条件，返回true，否则返回false
//1 .必须为女生；
//2. 姓名为4个字。
public static boolean checkStr(Predicate<String> p1, Predicate<String> p2, String string) {
    return p1.and(p2).test(string);
}
}

03.第一章：常用函数式接口_Function函数接口：

1).java.util.function.Function(函数接口)
2).抽象方法：
    1).R apply (T t):接收一种类型，返回另一种类型；
                   场景：将一种类型(String)转换为另一只类型(Integer)
3).默认方法：
    1).andThen():先做什么，后做什么，合并两个apply()的结果；
4).示例代码：
public class Demo {
public static void main(String[] args) {
    //1.R apply(T t):接收一种类型，返回另一种类型
    //例如：将一个String转换为Integer
    m1((s) -> Integer.parseInt(s), "24");

    2.andThen : 先做什么，使用结果再做什么，合并两个apply()的结果；
    //例如：1).将一个String的分数转换为Integer的分数 2).将刚才转换后的Integer再加10分
    m2((s) -> Integer.parseInt(s), (n) -> n + 10, "89");

}

//1.R apply(T t):接收一种类型，返回另一种类型
//例如：将一个String转换为Integer
public static void m1(Function<String, Integer> f, String string) {
    int a = f.apply(string);

    System.out.println("转换后的结果 + 10 : " + (a + 10));
}

//2.andThen : 先做什么，使用结果再做什么，合并两个apply()的结果；
//例如：1).将一个String的分数转换为Integer的分数 2).将刚才转换后的Integer再加10分
public static void m2(Function<String, Integer> f1, Function<Integer, Integer> f2,String score) {
    int s = f1.andThen(f2).apply(score);
    System.out.println("转换后的分数为：" + s);
}
}

04.第一章：常用函数式接口Function函数接口练习：

1).将字符串：
        String str = "赵丽颖, 20";
    按照顺序依次：
    1 . 将字符串截取数字年龄部分，得到字符串；
    2 . 将上一步的字符串转换成为int类型的数字；
    3 . 将上一步的int数字累加1 00， 得到结果int数字。
2).示例代码：
public class Demo {
public static void main(String[] args) {
    String str = "赵丽颖,24";
    /*
        1 . 将字符串截取数字年龄部分，得到字符串；
        2 . 将上一步的字符串转换成为int类型的数字；
        3 .将上一步的int数字累加1 00， 得到结果int数字。

     */
    // "赵丽颖,24"     "24"           "24"          24            24      124     "赵丽颖,24"
    m1((s) -> s.split(",")[1], (s) -> Integer.parseInt(s), (n) -> n + 100, str);

}

public static void m1(Function<String, String> f1,
                      Function<String, Integer> f2,
                      Function<Integer, Integer> f3,
                      String string) {
    int n = f1.andThen(f2).andThen(f3).apply(string);
    System.out.println("最终结果：" + n);
}

}

05.第一章：常用函数式接口总结延迟方法与终结方法：

1).延迟方法：默认方法；此方法会返回本接口类型，可以继续使用方法链调用。
2).终结方法：抽象方法；

06.第二章：Stream流_Stream流进行集合过滤的效果演示：

1).它不是IO流；
2).它是专门针对“集合”操作的一个流类，它类似于：迭代器。
   只是它可以支持Lambda，使用更快捷的方式操作集合；
3).Stream流进行集合过滤的效果演示：
public class Demo {
public static void main(String[] args) {
    List<String> list = new ArrayList<>() ;
    list. add("张无忌") ;
    list. add("周芷若") ;
    list. add("赵敏") ;
    list. add("张强") ;
    list. add("张三丰") ;

    //1.找出所有的姓张的学员，并打印
    /*for (String s : list) {
        if (s.startsWith("张")) {
            System.out.println(s);
        }
    }*/
    //2.只用Stream流
    list.stream().filter((str)->str.startsWith("张")).forEach((str)-> System.out.println(str));
}
}
注意："Stream流"不是集合，可以将它看成是"迭代器"，而且是一次性的，不能对一个Stream对象调用两次方法，所以只能用方法链；
        Stream<String> stream = list.stream();
        stream.filter((str)->str.startWith("张");
        stream.forEach((str)->System.out.println(str));//会引发异常
        -------------------------------------------------------
        Stream<String> stream = list.stream();
        stream = stream.filter((str)->str.startWith("张");
        stream.forEach((str)->System.out.println(str));//OK的
        --------------------------------------------------------
        list.stream()
            .filter((str)-> str.startsWith("张"))
            .forEach((str)-> System.out.println(str));

07.第二章：Stream流_流思想概述：

1).我们经常需要对集合中的元素进行一系列筛选，以前都是使用循环 + 判断。
   如果要进行一系列操作：例如：检索所有的“张姓”学员，然后再找出其中的男同学，然后年龄大于20岁的，然后取找到的前3个，使用“Stream”流可以很方便的进行操作。

08.第二章：Stream流获取List_Set_Map数组流：

1).List集合：
        List<String> list = new ArrayList<>();  
        ...
        Stream<String> stream = list.stream();
2).Set集合：
        Set<String> set = new HashSet<>();  
        ...
        Stream<String> stream = set.stream();
3).Map集合：
        Map<Integer,String> map = new HashMap<>();
        Set<Integer> keys = map.keySet();
        Stream<Integer> keyStream = keys.stream();
4).数组：
        int[] arr = {1,432,4,325,24,314,32};
        Stream<Integer> stream = Stream.of(arr);

09.第二章：Stream流常用方法过滤filter

1).Stream<T> filter(Predicate<? super T> predicate);
    示例代码：
    List<String> list = new ArrayList<>();
    ...
    list.stream().filter((s) -> s.startWith("张"));

10.第二章：Stream流常用方法逐一处理forEach

1).void forEach(Consumer<? super T> action);//消费接口
    示例代码：
    List<String> list = new ArrayList<>();
    ...
    list.stream()
        .filter((s) -> s.startWith("张"))
        .forEach(System.out::println);//.forEach((s)                 ->System.out.println(s);

11.第二章：Stream流常用方法统计个数count

示例代码：
  List<String> list = new ArrayList<>() ;
    list. add("张无忌") ;
    list. add("周芷若") ;
    list. add("赵敏") ;
    list. add("张强") ;
    list. add("张三丰") ;
    //3.count()
    System.out.println("数量：" + list.stream()
                                .filter((s)->s.startsWith  ("张")).count());

12.第二章：Stream流常用方法取用前几个limit

  List<String> list = new ArrayList<>() ;
    list. add("张无忌") ;
    list. add("周芷若") ;
    list. add("赵敏") ;
    list. add("张强") ;
    list. add("张三丰") ;


    //4.limit()
    list.stream()
            .filter(s->s.startsWith("张"))
            .limit(20)
            .forEach(System.out::println);

13.第二章：Stream流常用方法跳过前几个skip

list.stream()
    .filter(s -> s.startsWith("张"))
    .skip(2)
    .forEach(System.out::println);

14.第二章：Stream流常用方法映射（转换）map

Stream.of("10","20","30","40")
    .map(Integer::parseInt)
    .forEach(System.out::println);

15.第二章：Stream流常用方法合并2concat

Stream<String> s1 = Stream.of("10", "20", "30");
Stream<String> s2 = Stream.of("40", "50", "60");

Stream.concat(s2,s1).forEach(System.out::println);

16.第二章：Stream流练习集合元素处理的Stream方式：

有以下两个集合：
List<String> one = new ArrayList<>() ;
one. add("迪丽热巴") ;
one. add("宋远桥") ;
one. add("苏星河") ;
one. add("老子") ;
one. add("庄子") ;
one. add("孙子") ;
 one. add("洪七公") ;
List<String> two = new ArrayList<>() ;
two. add("古力娜扎") ;
two. add("张无忌") ;
two. add("张三丰") ;
two. add("赵丽颖") ;
two. add("张二狗") ;
two. add("张天爱") ;
two. add("张三") ;

还有一个类：
public class Person {
private String name;
public Person() {}
public Person(String name) {
this. name = name;
}@
Override
public String toString() {
return "Person{name=' " + name + "' }";
}
public String getName() {
return name;
}
public void setName(String name) {
this. name = name;
}
}
有以下要求：
    1).第一个队伍只要名字为3个字的成员姓名；
    2 . 第一个队伍筛选之后只要前3个人；
    3 . 第二个队伍只要姓张的成员姓名；
    4 . 第二个队伍筛选之后不要前2个人；
    5 . 将两个队伍合并为一个队伍；
    6 . 根据姓名创建 Person 对象；
    7 .打印整个队伍的Person对象信息。
---------------------------------------------------
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("洪七公") ;
    List<String> two = new ArrayList<>() ;
    two. add("古力娜扎") ;
    two. add("张无忌") ;
    two. add("张三丰") ;
    two. add("赵丽颖") ;
    two. add("张二狗") ;
    two. add("张天爱") ;
    two. add("张三") ;

    /*
    1 .第一个队伍只要名字为3个字的成员姓名；
    2 . 第一个队伍筛选之后只要前3个人；
    3 . 第二个队伍只要姓张的成员姓名；
    4 . 第二个队伍筛选之后不要前2个人；
    5 . 将两个队伍合并为一个队伍；
    6 . 根据姓名创建 Person 对象；
    7 .打印整个队伍的Person对象信息。
 */
    //1).第一个队伍只要名字为3个字的成员姓名；
//        one.stream().filter((s)->s.length() == 3).forEach(System.out::println);

    //2. 第一个队伍筛选之后只要前3个人；
//        one.stream().filter(s -> s.length() == 3).limit(3).forEach(System.out::println);

    // 3. 第二个队伍只要姓张的成员姓名；
//        two.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
    //4. 第二个队伍筛选之后不要前2个人；
//        two.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);
    //5. 将两个队伍合并为一个队伍；
//        Stream.concat(one.stream(),two.stream()).forEach(System.out::println);
    //6. 根据姓名创建 Person 对象；
    List<Person> pList = new ArrayList<>();
    Stream.concat(one.stream(),two.stream()).forEach((s)->pList.add(new Person(s)));
    //7. 打印整个队伍的Person对象信息。
    pList.stream().forEach(System.out::println);
}

17.第二章：Stream流总结拼接方法(延迟)与终结方法：

19.第二章：Stream流常用方法并行流parallel方法:

1).并行流：内部支持多线程调度；针对此流的每个操作都单独创建一个线程，可以提高检索的效率。尤其是对于包含很多元素的流，并进行很多过滤、筛选操作时。  
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();

for (int i = 0; i < 50000000; i++) {
    list.add(i);
}

System.out.println("封装完毕，开始检索：");
new Thread(()->{
    long start = System.currentTimeMillis();
    System.out.println(
            list.stream()
                    .filter((n)-> n % 2 == 0)
                    .filter(n -> n % 4 == 0)
                    .filter(n -> n % 5 == 0)
                    .filter(n -> n % 3 == 0)
                    .count());//1331 毫秒
    long end = System.currentTimeMillis();
    System.out.println("普通流，时间：" + (end - start) + " 毫秒");

}).start();
new Thread(()->{
    long start = System.currentTimeMillis();
    System.out.println(
            list.stream().parallel()
                    .filter((n)-> n % 2 == 0)
                    .filter(n -> n % 4 == 0)
                    .filter(n -> n % 5 == 0)
                    .filter(n -> n % 3 == 0)
                    .count());//2585 毫秒
    long end = System.currentTimeMillis();
    System.out.println("并行流，时间：" + (end - start) + " 毫秒");

}).start();
}

20.第二章：Stream流常用方法收集Stream结果collect方法

1).流转集合：
Stream<String> stream = Stream.of("10", "20", "30", "40");

List<String> strList = stream.collect(Collectors.toList());
Set<String> strSet = stream.collect(Collectors.toSet());

for (String s : strList) {
System.out.println(s);
}
2).流转数组：

Stream<String> stream = Stream.of("10", "20", "30", "40");

System.out.println("-------------------------");
Object[] objects = stream.toArray();
for (Object s : objects) {
    System.out.println(s);
}

21.第二章：Stream流练习将数组元素添加到集合中：

public static void main(String[] args) {
String[] strArray  ={"Java", "Groovy", "Scala", "Kotlin"};
List<String> strList = Stream.of(strArray).collect(Collectors.toList());

for (String s : strList) {
    System.out.println(s);
}
}

学习目标总结：
01.能够使用Function函数式接口
1).抽象方法：
1).R apply(T t):通常用于转换（String转换为Integer）
2).默认方法：
1).andThen():连接两个结果；

02.能够使用Predicate函数式接口
1).抽象方法：
1).boolean test(T t):测试
2).默认方法：
1).and:两次测试的并且
2).or :两次测试的或者
3).negate : 非
03.能够理解流与集合相比的优点
1).“流”是对“集合”操作的工具类，可以和Lambda一起提供非常方便的检索、过滤集合元素的方

    式，使操作集合比较方便。
2).集合就是用来存储数据的，有一些方法用于增删改查，但如果要进行一些过滤，就不是很方便了。

04.能够理解流的延迟执行特点
“流”的延迟：指仍然返回这种流对象，可以链式调用；

05.能够通过集合、 映射或数组获取流
List:
Stream m = list.stream();
Set:
Stream m = set.stream();
Map:
Set keys = map.keySet();
Stream keyStream = keys.stream();
数组：
Stream stream = Stream.of(数组对象/数值列表)
06.能够掌握常用的流操作
1).filter():过滤；
2).forEach():逐一获取；
3).limit():取前几个；
4).skip():跳过前几个；
5).count():统计数量
6).concat():合并两个流；
7).map():将一种类型的流转换为另一中类型的流；
8).paraller():获取并行流
9).collect():收集结果

07.能够使用流进行并发操作
1).获取并发流：
1).集合对象.parallerStream().正常调用
2).集合对象.stream().paraller().正常调用
08.能够将流中的内容收集到集合中
Stream stream = Stream.of(“10”,”20”,”30”);
List list = stream.collect(Collectors.toList());

09.能够将流中的内容收集到数组中
Stream stream = Stream.of(“10”,”20”,”30”);
Object[] objArray = stream.toArray();
…