
package demo02;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 14:52
 */
public class Test02 {
    public static void main(String[] args) {
        //开启线程  该构造函数需要传递一个Runnable类型的接口参数
        Thread thread = new Thread(new my());
        thread.start();//开启线程
        //匿名内部类
        Thread thread1=new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过匿名内部类实现线程任务");
            }
        });
    }
}
class my implements Runnable{
    @Override
    public void run() {
        System.out.println("使用实现类来完成---->线程任务");
    }
}

分析：

Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心

为了指定run方法体，不得不需要Runnable的实现类

为了省去定义一个Runnable 的实现类，不得不使用匿名内部类

必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，

而实际上，我们只在乎方法体中的代码.

我们可以使用lambda表达式来完成上面的功能

2.2 lambda表达式初体验


     //lambda表达式.
        Runnable runnable1=()->{
            System.out.println("这是lambda表达式完成线程任务");
        };
        Thread thread2=new Thread(runnable1);
        thread2.start();

2.3 lambda表达式的语法

(参数列表)-->{}

()：参数列表

->：连接符连接的是参数以及方法体。

{}：方法体

2.4 无参无返回值的Lambda表达式


package demo03;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 15:17
 */
public class Test03 {
    public static void main(String[] args) {
        //主函数调用fun方法。
        //第一种:创建UserService接口的实现类，并创建该实现类对象
        //第二种：匿名内部类的方式
//        UserService userService = new UserService() {
//            @Override
//            public void show() {
//                System.out.println("这是匿名内部类的show方法的实现");
//            }
//        };
//        fun(userService);
        //第三种lambda表达式:--该接口必须为函数式接口
        UserService userService = ()->{
            System.out.println("lambda表示的show方法");
        };
        fun(userService);
    }
    public static void fun(UserService userService){
        userService.show();
    }
}
//函数式接口-->里面有且仅有一个抽象方法。--只有这种接口才能使用lambda表达式
interface UserService{
    public void show();
}

2.5 有参有返回值的Lambda表达式


package demo04;
 
import com.sun.org.apache.bcel.internal.generic.NEW;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 16:14
 */
public class Test04 {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三",65));
        personList.add(new Person("李四",55));
        personList.add(new Person("王五",30));
        personList.add(new Person("赵六",47));
        personList.add(new Person("田七",31));
        System.out.println(personList);
        //对集合中的元素按照年龄排序，从小到大
        //Collections:集合工具类。--匿名内部类
//        Comparator<Person> comparator = new Comparator<Person>(){
//            @Override //如果是0表示相同 大于0表示o1大于02
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        };
//        Collections.sort(personList,comparator);
//        System.out.println(personList);
        Comparator<Person> comparator=(o1, o2) -> {
            //就是对函数式接口中抽象方法的简写
            return o1.getAge()-o2.getAge();
        };
        Collections.sort(personList,comparator);
        System.out.println(personList);
    }
}
 
class Person {
    private String name;
    private Integer age;
 
    public Person() {
    }
 
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
 
    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }
 
    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }
 
    /**
     * 获取
     * @return age
     */
    public Integer getAge() {
        return age;
    }
 
    /**
     * 设置
     * @param age
     */
    public void setAge(Integer age) {
        this.age = age;
    }
 
    public String toString() {
        return "Person{name = " + name + ", age = " + age + "}";
    }
}

2.6 Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

小括号内的参数类型可以省略[]

如果小括号内有且仅有一个参数，则小括号可以省略

如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。


package demo05;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 16:30
 */
public class Test05 {
    public static void main(String[] args) {
        USB u=str -> str.toUpperCase();//Lambda表达式;
//        USB u = new USB() { //匿名内部类对接口中抽象方法的个数没有任何要求
//            @Override
//            public String toUpper(String str) {
//                return null;
//            }
//
//            @Override
//            public String toLower(String str) {
//                return null;
//            }
//        };
        fun(u);
    }
    public static void fun(USB usb){
        String s = usb.toUpper("hello");
        System.out.println(s);
    }
}
interface USB {
    public String toUpper(String str);
//    public String toLower(String str);
}

2.7 Lambda表达式使用的前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

方法的参数或局部变量类型必须为接口才能使用Lambda

接口中有且仅有一个抽象方法(@FunctionalInterface)

后面我们使用lambda表达式主要核心使用再Stream流中。

三、内置函数式接口

要想使用lambda表达式它的前提就是必须是函数式接口。

3.1 内置函数式接口的由来


package demo06;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 17:07
 */
public class Test06 {
    public static void main(String[] args) {
        Operation o=arr -> {
            int sum = 0;
            for(int s :arr){
                sum+=s;
            }
            return sum;
        };
        fun(o);
    }
    public static void fun(Operation operation){
        int[] arr = {1,2,3,4};
        int s = operation.getSum(arr);
        System.out.println("数组的和为:"+s);
    }
}
@FunctionalInterface
interface Operation {
    public int getSum(int[] arr);
}

分析：

我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口. 大多数无需自己再定义函数式接口，而可以直接使用jdk内置的函数式接口。分成四类。

函数式接口的分类

函数式接口	参数类型	返回类型	说明
Consumer<T> 消费型接口	T	void	void accept(T t);对类型为T的对象应用操作
Supplier<T> 供给型接口	无	T	T get(); 返回类型为T的对象
Function<T,R> 函数型接口	T	R	R apply(T t);对类型为T的对象应用操作，并返回类型为R类型的对象。
Predicate<T> 断言型接口	T	boolean	boolean test(T t);确定类型为T的对象是否满足条件并返回boolean类型。

3.2 消费性函数式接口Consumer

适合有参数，但是没有返回值的


package demo07;
 
import java.util.function.Consumer;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 17:23
 */
public class Test07 {
    public static void main(String[] args) {
        Consumer<Double> c=t->{
            System.out.println("今天吃饭花费："+t+"元");
        };
        fun(c,20.5);
    }
    public static void fun(Consumer<Double> consumer,Double money){
        consumer.accept(money);
    }
}

3.3 供给型函数式接口Supplier

无参，需要返回值的接口类


package demo08;
 
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Supplier;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 17:23
 */
public class Test08 {
    public static void main(String[] args) {
//        Supplier<Integer> s = ()->new Random().nextInt(10);//十以内的随机数
//        fun(s);
        fun(()->new Random().nextInt(10));
    }
    public static void fun(Supplier<Integer> supplier){
        Integer a = supplier.get();
        System.out.println("结果:"+a);
    }
}

3.4 函数型函数式接口Function<T,R>

T: 参数的泛型

R:返回值的泛型


package demo09;
 
import java.util.function.Function;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 17:35
 */
public class Test09 {
    public static void main(String[] args) {
        Function<int[],Integer> o=arr->{
            int sum = 0;
            for(int s:arr){
                sum+=s;
            }
            return sum;
        };
        fun(o);
    }
    public static void fun(Function<int[],Integer> fun){
        int[] arr={1,2,3,4};
        int s = fun.apply(arr);
        System.out.println("数组的和:"+s);
    }
}

3.5 断言型函数式接口Predicate

T: 参数

boolean:返回值类型


package demo10;
 
import java.util.function.Predicate;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 19:15
 */
public class Test10 {
    public static void main(String[] args) {
        Predicate<String> p = t->t.length()>3;
        fun(p,"迪丽热巴");
    }
    public static void fun(Predicate<String> predicate,String name){
        boolean test = predicate.test(name);
        System.out.println("名字是否够长:"+test);
    }
}

四、方法引用

特殊的lambda表达式，它是对lambda表达式的一种简写方式。

4.1 方法引用的由来


package demo11;
 
import java.util.function.Consumer;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 19:38
 */
public class Test11 {
    public static void main(String[] args) {
        Consumer<int[]> c= t->{
            int sum=0;
            for(int a:t){
                sum+=a;
            }
            System.out.println("数组的和:"+sum);
        };
        fun(c);
    }
    public static void fun(Consumer<int[]> consumer){
        int[] arr={1,2,3,4,5};
        consumer.accept(arr);
    }
    //求和方法
    public static void sum(int[] arr){
        int sum=0;
        for(int a:arr){
            sum+=a;
        }
        System.out.println("数组的和:"+sum);
    }
}

如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，那是否还有必要再写重复逻辑？可以直接“引用”过去就好了：---方法引用 ::


package demo11.demo12;
 
import demo11.Test11;
 
import java.util.function.Consumer;
 
/**
 * @author huihui
 * @Project jdk8
 * @date 2023/6/13 19:40
 */
public class Test12 {
    public static void main(String[] args) {
//           Consumer<int[]> c=t->{
//                int sum=0;
//                for(int a:t){
//                    sum+=a;
//                }
//               System.out.println("数组的和:"+sum);
//           };
//        Consumer<int[]> c=(t)->Test07.sum(t); //
        Consumer<int[]> c = Test11::sum;
        fun(c);
    }
 
    public static void fun(Consumer<int[]> consumer) {
        int[] arr = {1, 2, 3, 4, 5};
        consumer.accept(arr);
    }
 
    //求和方法
    public static void sum(int[] arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        System.out.println("数组的和:" + sum);
    }
}

4.2 方法引用的类型

类型	语法	对应的Lambda表达式
静态方法引用	类名::staticMethodd	(args) -> 类名.staticMethod(args)
实例方法引用	inst::instMethod	(args) -> inst.instMethod(args)
对象方法引用	类名::instMethod	(inst,args) -> inst.instMethod(args)
构建方法引用	类名::new	(args) -> new 类名(args)

方法引用是Lambda表达式的一种简写形式。如果Lambda表达式方法中只是调用一个特定的已经存在的方法，则可以使用方法引用。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/726786