Lambda表达式的理解

Lambda表达式是Java8添加的一个新的特性，说白了Lambda表达式就是一个匿名函数
使用Lambda表达式可以对一个接口进行非常简洁的实现

接口的准备

1、无参无返回值的接口

/**无参无返回值的接口*/
@FunctionalInterface
public interface LambdaNNParamter {
    void test() ;
}

2、无参有返回值的接口

/**无参有返回值的接口*/
@FunctionalInterface
public interface LambdaNMParamter {
    int test();
}

3、有参有返回值的接口

/**有参有返回值的接口*/
@FunctionalInterface
public interface LambdaMMParamter {
    int test(int a);
}

lambda表达式语法

		//lambda是一个匿名函数
        //()表示参数
        //{}表示方法体
        // -> 表示lambda运算符


        /**无参无返回值*/
        LambdaNNParamter lambda1 = () -> System.out.println("hello word");
        lambda1.test();

        /**无参有返回值*/
        LambdaNMParamter lambda2 = () -> 1;
        System.out.println(lambda2.test());

        /**有参有返回值*/
        LambdaMMParamter lambda3 = a -> a*2;
        System.out.println(lambda3.test(10));

方法的引用

		//方法引用:
        //可以快速的将一个Lambda表达式的实现指向一个已经实现的方法
        //方法隶属者::方法名

        /**引用*/
        LambdaMMParamter lambda4 = LambdaTest::change;
        System.out.println(lambda4.test(10));

public class LambdaTest {

    public static void main(String[] arg){

        /**引用*/
        LambdaMMParamter lambda4 = LambdaTest::change;
        System.out.println(lambda4.test(10));

    }

    private static int change(int a){
        return a*3;
    }


}

构造方法的引用

定义一个类

public class Person {
    public int age;
    public String name;
    /**无参构造方法*/
    public Person(){
        System.out.println("我是无参构造方法");
    }
    /**有参构造方法*/
    public Person(String name,int age){
        this.age = age;
        this.name = name;
        System.out.println("我是有参构造方法");
    }

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

测试类

public class LambdaTest2 {
    public static void main(String[] args) {

        PersonCreater creater =() ->  new Person();
        creater.getPerson();

        //构造方法的引用
        PersonCreater creater1 = Person::new;
        creater.getPerson();

        PersonCreater2 creater2 = Person::new;
        creater2.getPerson("小米",11);
    }
}

interface PersonCreater{
    Person getPerson();
}

interface PersonCreater2{
    Person getPerson(String name,int age);
}

结果：

lambda表达式ArrayList集合排序

public class Exersice1 {
    //集合排序
    /**ArrayList<>*/
    public static void main(String[] args) {
        /**
         * 需求：
         * 已知在ArryList中有若干个Person类对象，将这些Person对象按照年龄来降序排序
         */

        List<Person> list = new ArrayList<>();

        list.add(new Person("小蓝",10));
        list.add(new Person("小红",11));
        list.add(new Person("小紫",10));
        list.add(new Person("小橙",20));

        //排序
        list.sort((o1,o2) -> o2.age - o1.age);

        System.out.println(list);
    }
}

结果：

lambda表达式TreeSet排序

public class Exersice2 {

    public static void main(String[] args) {
        //TreeSet排序
        //使用Lambda表达式来实现Comparator接口，并实例化一个TreeSet对象
        TreeSet<Person> set = new TreeSet<>((o1,o2) -> {
            if(o1.age >= o2.age){
                return -1;
            }else {
                return 1;
            }
        });

        set.add(new Person("小蓝",10));
        set.add(new Person("小红",11));
        set.add(new Person("小紫",10));
        set.add(new Person("小橙",20));

        System.out.println(set);

    }
}

结果：

lambda表达式ForEach

public class Exersice3 {
    public static void main(String[] args) {
        //集合的遍历
        ArrayList<Integer> list = new ArrayList<>();
        //添加元素
        Collections.addAll(list,1,2,3,4,5,6,7,8,9);

        for (Integer integer : list) {
            System.out.println(integer);
        }
        //将集合中的每一个元素带入到方法accept中
        list.forEach(System.out::println);

        //输出集合中的偶数
        list.forEach(elm -> {
            if(elm %2 == 0){
                System.out.println(elm);
            }
        });
    }
}

lambda使用removeif

public class Exersice4 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();

        list.add(new Person("小蓝",10));
        list.add(new Person("小红",11));
        list.add(new Person("小紫",10));
        list.add(new Person("小橙",20));

        //删除年龄大于10岁的元素  使用迭代器删除
        ListIterator<Person> it = list.listIterator();
        while (it.hasNext()){
            Person person = it.next();
            if (person.age > 10){
                it.remove();
            }
        }
        
        //使用lambda实现
        //将集合中的每一个元素都带入到test方法中，如果返回值是true将删除
        list.removeIf(t -> {
            if (t.age > 10){
                return true;
            }else {
                return false;
            }
        });
		
		//简化
        list.removeIf(t -> t.age>10);

        System.out.println(list);
    }
}

lambda表达式开辟一个线程，做一个输出

public class Exersice5 {
    public static void main(String[] args) {
        //使用lambda表达式开辟一个线程,做一个数字的输出
        Thread t = new Thread(() -> {
            for (int i =0; i<100; i++){
                System.out.println(i);
            }
        });
        t.start();
    }
}