常用函数式接口，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 p,String str){
boolean b = p.test(str);
System.out.println("字符串 " + str + " 的长度是否很长：" + (b ? "很长" : "不长"));
}
//2.默认方法：and():两个条件的并且关系
//需求：判断一个字符串中是否即包含大写的H又包含大写的W
public static void m2(Predicate p1, Predicate 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 p1, Predicate 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 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 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 p1, Predicate 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 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 f1, Function 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 f1,
Function f2,
Function 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 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 stream = list.stream();
stream.filter((str)->str.startWith("张");
stream.forEach((str)->System.out.println(str));//会引发异常
-------------------------------------------------------
Stream 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 list = new ArrayList<>();
...
Stream stream = list.stream();
2).Set集合：
Set set = new HashSet<>();
...
Stream stream = set.stream();
3).Map集合：
Map map = new HashMap<>();
Set keys = map.keySet();
Stream keyStream = keys.stream();
4).数组：
int[] arr = {1,432,4,325,24,314,32};
Stream stream = Stream.of(arr);
09.第二章：Stream流常用方法过滤filter
1).Stream filter(Predicate predicate);
示例代码：
List list = new ArrayList<>();
...
list.stream().filter((s) -> s.startWith("张"));
10.第二章：Stream流常用方法逐一处理forEach
1).void forEach(Consumer action);//消费接口
示例代码：
List list = new ArrayList<>();
...
list.stream()
.filter((s) -> s.startWith("张"))
.forEach(System.out::println);//.forEach((s) ->System.out.println(s);
11.第二章：Stream流常用方法统计个数count
示例代码：
List 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 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 s1 = Stream.of("10", "20", "30");
Stream s2 = Stream.of("40", "50", "60");
Stream.concat(s2,s1).forEach(System.out::println);
16.第二章：Stream流练习集合元素处理的Stream方式：
有以下两个集合：
List one = new ArrayList<>() ;
one. add("迪丽热巴") ;
one. add("宋远桥") ;
one. add("苏星河") ;
one. add("老子") ;
one. add("庄子") ;
one. add("孙子") ;
one. add("洪七公") ;
List 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 one = new ArrayList<>() ;
one. add("迪丽热巴") ;
one. add("宋远桥") ;
one. add("苏星河") ;
one. add("老子哥") ;
one. add("庄子第") ;
one. add("孙子") ;
one. add("洪七公") ;
List 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 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 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 stream = Stream.of("10", "20", "30", "40");
List strList = stream.collect(Collectors.toList());
Set strSet = stream.collect(Collectors.toSet());
for (String s : strList) {
System.out.println(s);
}
2).流转数组：
Stream 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 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();
…