12、四大函数式接口（重点）
函数接口：只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
//超级多@FunctionalInterface
//减缓编程模型，在新版本中的框架底层大量应用
//foreach(消费者类型的函数式接口)
1、Function函数式接口
package com.xing.function;
import java.util.function.Function;
/**
* Function 函数型接口 有一个输入参数 一个输出参数
* 只要是函数结构就可以用lambda简化
*/
public class demo01 {
public static void main(String[] args) {
//工具类：输出输入的值 参数的类型 返回值类型
/*Function function = new Function<String,String>() {
@Override
public String apply(String str) {
return str;
}
};*/
// Function<String,String> function = (参数) ->{代码;};
Function<String,String> function = (str) ->{return str;};
System.out.println(function.apply("ads"));
}
}
2、Predicate 断定型接口
有一个输入参数，返回值只能是 布尔值！
package com.xing.function;
import java.util.function.Predicate;
/*
断定型接口：有一个输入参数，返回值只能是boolean值
*/
public class demo02 {
public static void main(String[] args) {
//判断字符串是否为空 参数的类型
/* Predicate<String> predicate = new Predicate<String>(){
@Override
public boolean test(String str) {
return str.isEmpty();
}
};*/
Predicate<String> predicate = (str) -> {return str.isEmpty();};
System.out.println(predicate.test(""));//true
System.out.println(predicate.test("1"));//false
}
}
3、Consumer 消费型接口
package com.xing.function;
import java.util.function.Consumer;
/*
Consumer 消费型接口：只有输入，没有返回值
*/
public class demo03 {
public static void main(String[] args) {
// 参数类型
/*Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String str) {
System.out.println(str);
}
};*/
Consumer<String> consumer = (str) -> {
System.out.println(str);
};
consumer.accept("asb");//asb
}
}
4、Supplier 供给型接口
package com.xing.function;
import java.util.function.Supplier;
/*
supplier 供给型接口，不需要输入只有返回值
*/
public class demo04 {
public static void main(String[] args) {
// 返回值类型
/* Supplier supplier = new Supplier<Integer>(){
@Override
public Integer get() {
System.out.println("get()");
return 1024;
}
};*/
Supplier<Integer> supplier = () -> {return 1024;};
System.out.println(supplier.get());//1024
}
}
13、Stream流式计算（重点）
大数据：存储+计算
集合、MySQL本质就是存储东西的；计算都应该交给流！
常见使用方法：map（对对象进行操作）filter（对对象进行过滤）sorted（排序）limit（限制输出数量）
package com.xing.stream;标签：function,return,String,Stream,接口,User,2022.8,public,21 From： https://www.cnblogs.com/shanzha/p/16610989.html
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
/**
* 题目要求：一分钟完成此题，只能用一行代码解决
* 现在有五个用户！筛选：
* 1.ID必须是偶数
* 2.年龄必须大于23岁
* 3.用户名转为大写
* 4.用户名字母顺序倒序
* 5.只输出一个用户
*/
public class Test {
public static void main(String[] args) {
User u1 = new User(1,"a",21);
User u2 = new User(2,"b",22);
User u3 = new User(3,"c",23);
User u4 = new User(4,"d",24);
User u5 = new User(6,"e",25);
//集合就是存储
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
//计算交给流,链式编程
/*
* list.stream()：将list转换为流
* filter(Predicate<? super T> predicate):过滤 参数为断定型接口 看看断定型接口的简写方式
* map(Function<? super T, ? extends R> mapper): 映射 参数为函数式接口
* sorted(Comparator<? super T> comparator)：排序(默认正序) 参数为消费型接口
* limit(long maxSize)：输出的数据数
*/
list.stream()
.filter(u->{return u.getId()%2==0;})//判断偶数
.filter(u ->{return u.getAge() >23;})//判断大于23岁
.map(u -> {return u.getName().toUpperCase(Locale.ROOT);})//名字大写
//.sorted((uu1,uu2)->{return uu1.compareTo(uu2);})//正序
.sorted((uu1,uu2)->{return uu2.compareTo(uu1);})//倒序
.limit(1)
.forEach(System.out::println);//输出 E
}
}
class User{
private int id;
private String name;
private int age;
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}