lambda表达式

public class dome {
    public static void main(String[] args) {
        //该构造方法需要传递一个线程任务对象。Runnable类型
        a a = new a();
        Thread thread1 = new Thread(a);
        thread1.start();

        //匿名内部类
        Runnable runnable = new Runnable(){
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        //lambda表达式
        Runnable runnable1 = ()->{
            System.out.println("这是lambda表达式");
        };
        Thread thread2 = new Thread(runnable1);
        thread2.start();
    }
}
class  a implements Runnable{
    @Override
    public void run() {
        System.out.println("1111111111111111111111");
    }
}

public class dome {
    public static void main(String[] args) {
        swimmingTable swimmingTable = new swimmingTable(){
            @Override
            public void swimmning() {
                System.out.println("使用匿名方法");
            }
        };
        fun(swimmingTable);
        //lambda形式
       /* swimmingTable swimmingTable1 = ()->{
            System.out.println("使用lambda表达形式");
        };*/

        fun(()->{
            System.out.println("使用lambda表达形式");
        });
    }
    public static void fun(swimmingTable w){
        w.swimmning();
    }
}
interface  swimmingTable{
    public void swimmning();
}

public class dome {
    public static void main(String[] args) {
        //内置函数式接口的由来
        Operater operater = arr->{
            int sum = 0;
            for (int n:arr){
                sum+=n;
            }
            System.out.println("数组和为："+sum);
        };
        fun(operater);
    }
    public static void fun(Operater operater){
        int[] arr={2,3,4,5,6,7,11};
        operater.geuSum(arr);
    }
}
interface Operater{
    //求数组的和
    public abstract void geuSum(int[] arr);
}

package dpome7;

import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Function;

public class dome {
    public static void main(String[] args) {
        List<People> list = new ArrayList<>();
        list.add(new People("王文超1",20,178));
        list.add(new People("王文超2",30,178));
        list.add(new People("王文超",10,178));
        list.add(new People("王文超3",240,178));
        //对集合中的元素进行排序 按照年龄从大到小。
        /*Comparator<People> peopleComparator = new Comparator<People>(){

            @Override
            public int compare(People o1, People o2) {
                return o1.getAge()-o2.getAge();
            }
        };
        Collections.sort(list,peopleComparator);
        for (People p:list){
            System.out.println(p);
        }*/
        //lambda表达式为
        Comparator<People> comparator = (People o1,People o2)->{
            return o1.getAge()-o2.getAge();
        };
        Collections.sort(list,comparator);
        for (People p:list){
            System.out.println(p);
        }
    }

}
class People{
    private String name;
    private int age;
    private int height;

    public People(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class dome {
    public static void main(String[] args) {
        //有参数，无返回值。
        Consumer consumer = t->{
            System.out.println("洗脚花了:"+t);
        };
        fun(consumer,2000.0);
    }
    //调用某个方法时，该方法需要的参数为接口类型，这时就应该 能想到使用lambda
    public static void fun(Consumer<Double> consumer,Double money){
        consumer.accept(money);
    }
}

public class dome {
    public static void main(String[] args) {
        //无参，想有返回结果的函数式接口时
        fun(()->new Random().nextInt(10)); {

        };
    }
    public static void fun(Supplier<Integer> supplier){
        Integer integer = supplier.get();
        System.out.println("随机数字为:"+integer);
    }
}

public class dome {
    public static void main(String[] args) {
        //传入一个字符串把小写转换为大写
        fun((t)->{
            return t.toUpperCase();
        },"hello world");
    }
    public static void fun(Function<String,String> function,String msg){
        String apply = function.apply(msg);
        System.out.println("结果为："+apply);
    }
}

public class dome2 {
    public static void main(String[] args) {
    //当传入一个参数时，需要对该参数进行判断时，则需要这种函数。
        fun((t)->{
            return t.length()>3?true:false;
        },"王文超十大帅哥");
    }
    public static void fun(Predicate<String> predicate,String name){
        boolean test = predicate.test(name);
        System.out.println("是否符合姓名大于三："+test);
    }
}