1.1 概念
Lambda表达式: 特殊的匿名内部类，语法更加简洁
- Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递
1.2 需求
1、开启一个线程。并执行一个Runnable类型的任务。
public class Test01 {
public static void main(String[] args) {
//匿名内部类
Runnable tast1=new Runnable() {
public void run() {
System.out.println("这是使用匿名内部类"+Thread.currentThread().getName());
}
};
new Thread(tast1).start();
System.out.println("主线程的内容:"+Thread.currentThread().getName());
}
}
分析代码:
1.Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
2. 为了指定run方法体，不得不需要Runnable的实现类
3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
5. 而实际上，我们只在乎方法体中的代码
使用Lambda表达式来解决这个问题.
1.3 初体验Lambda表达式
lambda就是匿名内部类的一种简写版，语法更加简洁。
System.out.println("====================================================");
Runnable tast2=()->{
System.out.println("这是使用lambda表达式:"+Thread.currentThread().getName());
};
new Thread(tast2).start();
1.4 lambda的语法
lambda表达式它由三部分组成
(数据类型 变量名,数据类型 变量名)->{方法体}
格式说明：
- (参数类型 参数名称):参数列表
- {代码体;} :方法体
- -> : 箭头，分割参数列表和方法体
1.5 Lambda练习1
无参无返回值的Lambda
package com.zks.jdk.lambda02;
public class Test02 {
public static void goShow(UserService userService){
userService.show();
}
public static void main(String[] args) {
//1.自己创建一个UserService接口的实现类。并创建该类的对象。
UserService userService=new UserServiceImpl();
goShow(userService);
//2.使用匿名内部类
UserService userService1=new UserService() {
@Override
public void show() {
System.out.println("这是UserService的匿名实现类");
}
};
goShow(userService1);
//3.使用lambda表达式
UserService userService2=()->{
System.out.println("这是lambda表达式");
};
goShow(userService2);
}
}
interface UserService{
public void show();
}
class UserServiceImpl implements UserService{
@Override
public void show() {
System.out.println("这是UserService实现方法");
}
}
1.6 Lambda练习2
完成一个有参且有返回值得Lambda表达式案例.
创建一个People对象
@Data
@NoArgsConstructor
@AllArgsConstructor
class People{
private String name;
private int age;
}
测试:
public class Test03 {
public static void main(String[] args) {
List<People> list=new ArrayList<People>();
list.add(new People("张三",15));
list.add(new People("李四",17));
list.add(new People("王五",16));
list.add(new People("小明",26));
//按照年龄进行排序。第二个参数需要传递排序规则
// Comparator<People> comparator=new Comparator<People>() {
// public int compare(People o1, People o2) {
// return o1.getAge()-o2.getAge();
// }
// };
// Collections.sort(list,comparator);
// System.out.println(list);
System.out.println("=============================================");
Comparator<People> comparator1=(People o1,People o2)->{return o2.getAge()-o1.getAge();};
Collections.sort(list,comparator1);
System.out.println(list);
}
}
结果:
[People(name=小明, age=26), People(name=李四, age=17), People(name=王五, age=16), People(name=张三, age=15)]
1.7 lambda表达式的缩写版
在lambda表达式的标准写法基础上，可以使用省略写法的规则为：
- 小括号内的参数类型可以省略
- 如果小括号内有且仅有一个参数，则小括号可以省略
- 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
package com.zks.jdk.lambda03;
public class Test03 {
public static void main(String[] args) {
// UserService userService=(String name,int age)->{return name+"~~~~~"+age;};
UserService userService=(name, age)-> name+"~~~~~"+age ;//可以省略lambda表达式参数的类型,以及{}和return 和分号；
goUserService(userService);
// StudentService studentService=(name)->{ System.out.println("我叫:"+name);};
// StudentService studentService= name->{ System.out.println("我叫:"+name);}; //int a=15;
goStudentService(name->{ System.out.println("我叫:"+name);});
}
public static void goStudentService(StudentService studentService){
studentService.print("罗江超");
}
public static void goUserService(UserService userService){//1.方法的参数必须是一个接口类型。 2.该接口有且只有一个抽象方法。
String s = userService.show("褚松明", 15);
System.out.println(s);
}
}
@FunctionalInterface
interface UserService{ //为了防止别人往该接口中添加新的抽象方法，可以使用一个注解FunctionInterface。
public String show(String name,int age);
default void fun(){};
}
interface StudentService{
public void print(String name);
}
1.8 lambda表达式使用的前提
Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意
-
方法的参数或局部变量类型必须为接口才能使用Lambda
-
接口中有且仅有一个抽象方法(@FunctionalInterface)
-
jdk1.8后接口中新增了那些成员
jdk1.8以前
public interface 接口名{
//静态常量
//抽象方法
}
jdk1.8以后
public interface 接口名{
//静态常量
//抽象方法
//默认方法
//静态方法
}
2.1 默认方法
格式:
修饰符 default 返回类型 方法名(){}
为什么接口中新增默认方法。
在JDK8以前接口中只能有抽象方法和静态常量，会存在以下的问题：
如果接口中新增抽象方法，那么实现类都必须重写这个抽象方法，非常不利于接口的扩展的
public interface Usb {
public static final String n="";
public abstract void fun();
//如果接口中新增一个方法，那么它的所有实现类都必须重写该方法，不利于接口的扩展。
public abstract void print();
}
class Upan implements Usb{
@Override
public void fun() {
System.out.println("upan重写了fun方法");
}
@Override
public void print() {
}
}
class Mouse implements Usb{
@Override
public void fun() {
System.out.println("鼠标重写了fun方法");
}
@Override
public void print() {
}
}
2.2 静态方法
- 为了接口的扩展。
格式:
修饰符 static 返回类型 方法名(){}
public interface Usb {
public static final String n="";
public abstract void fun();
//如果接口中新增一个方法，那么它的所有实现类都必须重写该方法，不利于接口的扩展。
public abstract void print();
public default void haha(){ //默认方法可以被重写。只可以通过对象调用
System.out.println("我是哈哈");
}
public static void hehe(){ //静态的方法不能被重写 只可以通过接口名调用。
System.out.println("这是接口中的静态方法hehe");
}
}
3.2 静态方法的使用
接口中的静态方
法在实现类中是不能被重写的，调用的话只能通过接口类型来实现: 接口名.静态方法名();
-
两者的区别介绍
-
默认方法通过实例调用，静态方法通过接口名调用
-
默认方法可以被继承，实现类可以直接调用接口默认方法，也可以重写接口默认方法
-
静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名调用
-
函数式接口
我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口。
public class Test {
public static void main(String[] args) {
//求数组种所有数据的和。
int[] a1={1,2,3,4};
My my=arr -> {
int sum=0;
for (int i = 0; i <arr.length ; i++) {
sum+=arr[i];
}
return sum;
};
fun(my,a1);
}
public static void fun(My my,int[] a1){
int b=my.sum(a1);
System.out.println("数组a1种所有元素的和:"+b);
}
}
//因为每个人定义函数式接口的名字不统一，而且方法名也不统一。
interface My{
public int sum(int[] arr);
}
jdk提供的函数式接口 java.util.function包下。
-
Consumer 消费型函数式接口 有参无返回值
void accept(T t);
-
Function 函数型函数式接口 有参有返回值
R apply(T t);
-
Supplier 供给型函数式接口 无参有返回值
T get();
-
Predicate 断言型函数式接口 有参返回值为boolean.
boolean test(T t);
2.1 Supplier
无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型。
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
使用：
/**
* Supplier 函数式接口的使用
*/
public class SupplierTest {
public static void main(String[] args) {
fun1(()->{
int arr[] = {22,33,55,66,44,99,10};
// 计算出数组中的最大值
Arrays.sort(arr);
return arr[arr.length-1];
});
}
private static void fun1(Supplier<Integer> supplier){
// get() 是一个无参的有返回值的 抽象方法
Integer max = supplier.get();
System.out.println("max = " + max);
}
}
2.2 Consumer
有参无返回值得接口,前面介绍的Supplier接口是用来生产数据的，而Consumer接口是用来消费数据的，使用的时候需要指定一个泛型来定义参数类型
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
}
使用：将输入的数据统一转换为小写输出
public class ConsumerTest {
public static void main(String[] args) {
test(msg -> {
System.out.println(msg + "-> 转换为小写：" + msg.toLowerCase());
});
}
public static void test(Consumer<String> consumer){
consumer.accept("Hello World");
}
}
默认方法:andThen
如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default方法 andThen方法
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
具体的操作
public class ConsumerAndThenTest {
public static void main(String[] args) {
test2(msg1->{
System.out.println(msg1 + "-> 转换为小写：" + msg1.toLowerCase());
},msg2->{
System.out.println(msg2 + "-> 转换为大写：" + msg2.toUpperCase());
});
}
public static void test2(Consumer<String> c1,Consumer<String> c2){
String str = "Hello World";
//c1.accept(str); // 转小写
//c2.accept(str); // 转大写
//c1.andThen(c2).accept(str);
c2.andThen(c1).accept(str);
}
}
2.3 Function
有参有返回值的接口，Function接口是根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。有参数有返回值。
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}
使用：传递进入一个字符串返回一个数字
public class FunctionTest {
public static void main(String[] args) {
test(msg ->{
return Integer.parseInt(msg);
});
}
public static void test(Function<String,Integer> function){
Integer apply = function.apply("666");
System.out.println("apply = " + apply);
}
}
默认方法：andThen，也是用来进行组合操作，
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
public class FunctionAndThenTest {
public static void main(String[] args) {
test(msg ->{
return Integer.parseInt(msg);
},msg2->{
return msg2 * 10;
});
}
public static void test(Function<String,Integer> f1,Function<Integer,Integer> f2){
/*Integer i1 = f1.apply("666");
Integer i2 = f2.apply(i1);*/
Integer i2 = f1.andThen(f2).apply("666");
System.out.println("i2:" + i2);
}
}
默认的compose方法的作用顺序和andThen方法刚好相反
而静态方法identity则是，输入什么参数就返回什么参数
2.4 Predicate
有参且返回值为Boolean的接口
@FunctionalInterface
public interface Predicate<T> {
/**
* Evaluates this predicate on the given argument.
*
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);
}
使用：
public class PredicateTest {
public static void main(String[] args) {
test(msg -> {
return msg.length() > 3;
},"HelloWorld");
}
private static void test(Predicate<String> predicate,String msg){
boolean b = predicate.test(msg);
System.out.println("b:" + b);
}
}
在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法
package com.zks.jdk.fun;
import java.util.function.Predicate;
public class PredicateDefaultTest {
public static void main(String[] args) {
test(msg1 -> {
return msg1.contains("H");
},msg2 -> {
return msg2.contains("W");
});
}
private static void test(Predicate<String> p1,Predicate<String> p2){
/*boolean b1 = predicate.test(msg);
boolean b2 = predicate.test("Hello");*/
// b1 包含H b2 包含W
// p1 包含H 同时 p2 包含W
boolean bb1 = p1.and(p2).test("Hello");
// p1 包含H 或者 p2 包含W
boolean bb2 = p1.or(p2).test("Hello");
// p1 不包含H
boolean bb3 = p1.negate().test("Hello");
System.out.println(bb1); // FALSE
System.out.println(bb2); // TRUE
System.out.println(bb3); // FALSE
}
}
扫一扫
1577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
