内容

1、Lambda表达式
2、函数式接口
3、StreamingAPI

Lambda表达式

1、是对匿名内部类对象的一种格式的简化
2、Java8中引入了一个新的操作符“->”，称为箭头运算符，或者Lambda运算符
3、作用：就是用于分隔前后两部分的
4、左边：表示Lambda表达式的参数列表（接口中，定义的抽象方法的参数）
5、右边：表示的是方法的方法体，Lambda体

格式

语法格式1：没有参数，也没有返回值
() -> System.out.println(“Hello Lambda”);

语法格式2：有一个参数，没有返回值
(x) -> System.out.println(x * x);
说明：如果只有一个参数，那么小括号可以省略

语法格式3：有多个参数，没有返回值，格式和语法格式2相同
(x, y) -> System.out.println(x + y);

语法格式4：接口中需要重写的方法，方法内容有多句，需要给多句话加上大括号
例如：(x, y) -> {int result = x + y; return result;}

注意事项：如果Lambda体中语句只有一句，那么大括号可以省略不写；
如果大括号中只有一条语句，并且是return语句，
那么return关键字也可以省略不写（如果要省略return关键字，就必须省略大括号）

public class Demo01_Lambda表达式的好处 {

public static void main(String[] args) {
test2_有Lambda表达式的形式();
}

private static void test2_有Lambda表达式的形式() {
MyInter1 mi2 = () -> System.out.println("test1方法被调用了");
mi2.test1();
}

private static void test1_没有Lambda表达式的方式() {
MyInter1 mi1 = new MyInter1() {
@Override
public void test1() {
System.out.println("test1方法被调用了");
}
};
mi1.test1();
}
}

interface MyInter1 {
public abstract void test1();
}

函数式接口（默认的，拿过来就用，在括号参数的位置实现方法重写，不需要再new接口了）

整理：

Consumer<T>:消费型接口（有钱咱就花）
接收一个数据，并且处理这个数据，处理完成之后，
不需要返回任何数据，直接输出
con.accept();

Supplier<T>:供给型接口（后勤）
提供需要用到的数据
sup.get();

Function<T, R>:函数型接口（乾坤大挪移）
接收T类型转换为R类型
fun.apply();

Predicate<T>:断言型接口（包公断案）
判断对与错，把控if关卡

boolean    test(T t);
Predicate  and(Predicate pre)：返回两个条件的都满足的判断对象
Predicate  or(Predicate pre)：返回两个条件任意一个满足的判断对象
Predicate  negate()：返回的是调用者判断条件的取反

//消费型接口
//
import java.util.function.Consumer;

public class Demo01 {
public static void main(String[] args) {
test(2000, t -> System.out.println("做了个：" + t), "大宝剑");

}

public static void test(int money,Consumer<String> con,String str) {
System.out.println("花了"+money+"钱");
con.accept(str);
}

}

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Supplier;

//供给型接口
//生成10个100以内的随机数存储到List集合中
public class Demo01 {
public static void main(String[] args) {
Random rd = new Random();
List<Integer> list = new ArrayList<Integer>();

list = getRandom(10, () -> rd.nextInt(100));

System.out.println(list);
}

//
public static List<Integer> getRandom(int n, Supplier<Integer> sup) {
List<Integer> list1 = new ArrayList<Integer>();

for (int i = 0; i < n; i++) {
list1.add(sup.get());
}

return list1;
}
}

import java.util.function.Function;

//函数式接口

public class Demo01 {
public static void main(String[] args) {
String str = conver(666, t -> String.valueOf(t));
System.out.println(str);
}

public static String conver(int num, Function<Integer, String> fun) {

return fun.apply(num);
}
}

import java.util.ArrayList;
import java.util.function.Predicate;

//函数式接口之断言型接口
public class Demo {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(66);
list.add(666);
list.add(35);
list.add(-20);
list.add(0);
list.add(33);

// 筛选出list集合中大于100的数字
ArrayList<Integer> result = filtneg(list, t -> t % 2 == 0);
System.out.println(result);

// 筛选出list集合中偶数且大于100的数字
}

//
public static ArrayList<Integer> filt(ArrayList<Integer> list, Predicate<Integer> pre, Predicate<Integer> pre2) {
ArrayList<Integer> result = new ArrayList<Integer>();
for (Integer i : list) {
if (pre.and(pre2).test(i)) {
result.add(i);
}
}

return result;
}

public static ArrayList<Integer> filtor(ArrayList<Integer> list, Predicate<Integer> pre, Predicate<Integer> pre2) {
ArrayList<Integer> result = new ArrayList<Integer>();
for (Integer i : list) {
if (pre.or(pre2).test(i)) {
result.add(i);
}
}

return result;
}

public static ArrayList<Integer> filtneg(ArrayList<Integer> list, Predicate<Integer> pre) {
ArrayList<Integer> result = new ArrayList<Integer>();
for (Integer i : list) {
if (pre.negate().test(i)) {
result.add(i);
}
}

return result;
}
}

StreamingAPI

概述

1、在jdk1.8中，提供了一个Stream类型，可以对数据进行过滤
2、好处：
比不断的自定义循环，要简单很多

常用方法

Stream<T>  filter(Predicate<? super T> pre)
根据pre描述的判断条件，对流中的数据进行过滤

Stream<T>  limit(long maxSize)
根据参数maxSize描述的个数，对流中的数据进行截取

Stream<T>  skip(long n)
跳过参数n描述的个数，流中剩余的是n之后的内容

Stream<R>  map(Function<? super T, R> fun )
将流中的所有T类型数据，都根据fun这个函数型接口，转换成其他的R类型数据

forEach(Consumer<? super T>  con)
将流中的数据，根据con描述的处理方式，进行处理

long count()
返回流中的元素数

import java.util.ArrayList;

public class Demo {
public static void main(String[] args) {
ArrayList<String> names = new ArrayList<>();
names.add("张无忌");
names.add("张三丰");
names.add("周芷若");
names.add("时哥");
names.add("赵云");
names.add("苇名一心");

// 截取
testLimit(names);

// 跳过
testSkip(names);

// 转换
testMap(names);
}

private static void testMap(ArrayList<String> names) {
names.stream().map(t -> t.length()).forEach(System.out::println);
}

private static void testSkip(ArrayList<String> names) {
names.stream().skip(3).forEach(System.out::println);
}

private static void testLimit(ArrayList<String> names) {
names.
3ff7
stream().limit(3).forEach(System.out::println);
}
}

Stream类型数据的获取

1、Collection的获取：
调用stream()方法即可，返回Stream类型的对象
2、Map的获取：不能直接获取Stream类型
1、keySet().stream()
2、values().stream()
3、entrySet().stream()
3、数组的获取
Stream中的of方法，Stream.of(数组)

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream;

public class Demo {
public static void main(String[] args) {
int[] num = { 1, 2, 3, 4, 5, 6 };

//数组型的stream对象获取
Stream<int[]> num_Stream = Stream.of(num);

//map类型的
Map<String, String> map = new HashMap<String, String>();
map.put("CN", "中国");
map.put("US", "美国");
map.put("JP", "日本");
Stream keyStream = map.keySet().stream();
map.values().stream();
map.entrySet().stream();
}
}

作业

有两个Arraylist集合，存储队伍中的多个成员姓名，使用Stream方式，对以下步骤进行操作
1、第一个队伍只要名字为3个字的成员姓名
2、第一个队伍只要筛选之后的前三个人

3、第二个队伍只要姓张的
4、第二个队伍筛选之后不要前两个人

5、将两个队伍合并成一个队伍
6、合并之后的队伍中的所有人的Person（自定义类型）对象，存储到一个ArrayList集合中

队伍1：宫本武藏、宋公明、苏有朋、石头人、时传祥、李耳、庄子、洪七公
队伍2：帕瓦罗蒂、张三疯、赵薇薇、张自忠、孛儿只斤铁木真、张天爱、张翠花

答案

累了，不想写