一.Java8四大内置函数式接口
1、Consumer 消费性接口:void accept(T t); 有一个参数传入,无返回值
2、Supplier供给型接口: T get(); 无参数传入,有一个返回值
3、Function 函数式接口:R apply(T t); 有一个参数传入,有一个返回值
4、Predicate 断言式接口:boolean test(T t); 有一个参数传入,返回一个boolean值
二.测试
import java.util.Comparator;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* @author qinxun
* @date 2023-06-02
* @Descripion: lambda学习
*/
public class LambdaDemo {
public static void main(String[] args) {
test1();
test2();
test3();
test4();
test5();
test6();
test7();
}
/**
* 普通匿名内部类实现多线程
*/
public static void test1() {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类,实现线程启动");
}
});
thread.start();
}
/**
* lambda表达式 无参数传入,无返回值
*/
public static void test2() {
Thread thread = new Thread(() -> System.out.println("lambda表达式,实现线程启动"));
thread.start();
}
/**
* lambda中的Consumer接口 有一个参数传入,无返回值
*/
public static void test3() {
Consumer<Integer> consumer = data -> System.out.println("您的年龄:" + data);
consumer.accept(28);
}
/**
* lambda表达式中的Predicate 有一个参数传入,返回一个boolean值
*/
public static void test4() {
// 参数和默认值进行比较 返回boolean值
Predicate<Integer> predicate = data -> data > 60;
//传入参数70
boolean flag = predicate.test(70);
System.out.println(flag);
}
/**
* lambda表达式中的Supplier 无参数传入,有一个返回值
*/
public static void test5() {
Supplier<Integer> supplier = () -> {
Random random = new Random();
// 返回一个0-9之间的整数
return random.nextInt(10);
};
System.out.println(supplier.get());
}
/**
* lambda表达式中的Function 有一个参数传入,有一个返回值
*/
public static void test6() {
Function<Integer, String> function = age -> age > 60 ? "可以退休了" : "还没有到退休年龄";
String result = function.apply(65);
System.out.println(result);
}
/**
* Comparator 有两个的参数,有返回值
*/
public static void test7() {
// 返回两个参数的最大值
Comparator<Integer> comparator = (x, y) -> x > y ? x : y;
int max = comparator.compare(3, 4);
System.out.println(max);
}
}
匿名内部类,实现线程启动
lambda表达式,实现线程启动
您的年龄:28
true
2
可以退休了
4
三、方法引用与构造器引用
实现抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致!
方法引用:使用操作符“::”将类与方法分隔开来。
对象::实例方法名
类::静态方法名
类::实例方法名
/**
* 方法引用测试
*/
public static void test8() {
// 没有使用方法引用的情况
Comparator<Double> comparator1 = (x, y) -> Double.compare(x, y);
// 使用方法引用
Comparator<Double> comparator2 = Double::compare;
// 两种方式返回的数据一样
System.out.println(comparator1.compare(3.0, 4.0));
System.out.println(comparator2.compare(3.0, 4.0));
// 普通小写转换大写
Function<String, String> consumer1 = s -> s.toUpperCase();
// 构造器引用
Function<String, String> consumer2 = String::toUpperCase;
System.out.println(consumer1.apply("hello"));
System.out.println(consumer2.apply("hello"));
}
-1
-1
HELLO
HELLO
四、lambda表达式的一些常见用法
1.数据迭代
/**
* 数据迭代输出
*/
public static void test9(){
List<String> list = Arrays.asList("a","b","c");
list.forEach(System.out::println);
}
a
b
c
2、map转换数据
/**
* 转换数据 小写变大写
*/
public static void test10() {
List<String> list = Arrays.asList("a", "b", "c");
List<String> stringList = list.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());
// 输出[A, B, C]
System.out.println(stringList);
}
3、reduce规约
/**
* reduce求和
*/
public static void test11() {
List<Integer> list = Arrays.asList(1, 2, 3);
Integer result = list.stream().reduce(0, Integer::sum);
// 输出6
System.out.println(result);
}
4、filter过滤操作
/**
* filter过滤数据
*/
public static void test12(){
List<Integer> list = Arrays.asList(2,5,1,3,6,7);
// 过滤获取大于3的数据
List<Integer> resultList = list.stream().filter(s -> s > 3).collect(Collectors.toList());
// 输出[5, 6, 7]
System.out.println(resultList);
}