lambda表达式与函数接口的关系以及使用案例

lambda表达式与函数式接口是结合使用的。

函数式接口：接口中只有一个抽象方法的接口，其中可以包括default修饰，static 修饰的实例方法。函数式接口可以在接口上添加@FuncationInterface注解（也可以不加），实现方式可以与普通接口一样，通过定义一个实现类实现该接口，也可以通过匿名类形式实现，新增的实现方式通过lambda表达式。

lambda表达式可以理解为：对函数式接口和其中抽象方法的实现。当需要一个函数式接口参数的方法时，我们就可以给其传递一个对应的lambda表表达式作为参数，执行时会自动执行函数式接口中的唯一方法，也就是传递过去的lambda表达式。

函数式接口例如：Comparator接口

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Java8Test1 {

    public static void main(String[] args) {
        
        /**
         * 传统实现方式
         */
        String [] str = {"a","v","n","r"};
        List<String> asList = Arrays.asList(str);
        System.out.println("初始状态："+asList);
        asList.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // TODO Auto-generated method stub
                return o1.compareTo(o2);
            }
        });
        System.out.println("传统方式："+asList);
        /**
         * 采用lambda表达式方式 方式一
         */
        String [] str1 = {"a","v","n","r"};
        List<String> list = Arrays.asList(str);
        //lambda表达式对compartor函数数式接口实现
        Comparator<String> comparator = (String o1,String o2)->(o1.compareTo(o2));
        list.sort(comparator);
        System.out.println("lambda表达式返回值："+list);
        /**
         * 采用lambda表达式  方式二
         */
        String [] str2 = {"a","v","n","r"};
        List<String> list1 = Arrays.asList(str);
        //将lambda表达式作为参数传递
        list1.sort((String o1,String o2)->(o1.compareTo(o2)));
        System.out.println("lambda表达式直接作为参数："+list1);
        
    }
}

View Code

运行结果：

初始状态：[a, v, n, r]
传统方式：[a, n, r, v]
lambda表达式返回值：[a, n, r, v]
lambda表达式直接作为参数：[a, n, r, v]

实现两个学生对象按照成绩排序实现方式

定义一个学生类

package cn.sanchuanmu.pojo;

public class Student {

    private String name;
    
    private int age;
    
    private double socre;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getSocre() {
        return socre;
    }

    public void setSocre(double socre) {
        this.socre = socre;
    }
    
}

View Code

方式一：采用传统方式实现

package cn.sanchuanmu.sort;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

import cn.sanchuanmu.pojo.Student;

public class DemoSort {

    /**
     * 实现对两个student对象的成绩进行排序
     * @param args
     */
    public static void main(String[] args) {
        
        Student student1 = new Student();
        student1.setName("张三");
        student1.setAge(23);
        student1.setSocre(16.66);
        
        Student student2 = new Student();
        student2.setName("李四");
        student2.setAge(24);
        student2.setSocre(24);
        
        Student student3 = new Student();
        student3.setName("张三");
        student3.setAge(23);
        student3.setSocre(20);
        
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i).getName()+list.get(i).getSocre());
        }
        
        System.out.println("-------------------------排序之前----------------------------");
        getSortBySocre(list);  //传统方式实现
        
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i).getName()+list.get(i).getSocre());
        }
        
    }

    public static  void getSortBySocre(ArrayList<Student> list) {
        // TODO Auto-generated method stub
        list.sort(new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                // TODO Auto-generated method stub
                
                return (int) (o1.getSocre()-o2.getSocre());
            }
        });
    }
    
}

View Code

方式二：采用lambda表达式方式实现

package cn.sanchuanmu.sort;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

import cn.sanchuanmu.pojo.Student;

public class DemoSort {

    /**
     * 实现对两个student对象的成绩进行排序
     * @param args
     */
    public static void main(String[] args) {
        
        Student student1 = new Student();
        student1.setName("张三");
        student1.setAge(23);
        student1.setSocre(16.66);
        
        Student student2 = new Student();
        student2.setName("李四");
        student2.setAge(24);
        student2.setSocre(24);
        
        Student student3 = new Student();
        student3.setName("张三");
        student3.setAge(23);
        student3.setSocre(20);
        
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i).getName()+list.get(i).getSocre());
        }
        
        System.out.println("-------------------------排序之前----------------------------");
    
        getLamdaSort(list);
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i).getName()+list.get(i).getSocre());
        }
        
    }


    
    public static void getLamdaSort(List<Student> list){
        
    Comparator<Student> comparator = (Student o1,Student o2)->{return (int) (o1.getSocre()-o2.getSocre());};
    
    list.sort(comparator);
    }
}

View Code

lambda表达式与函数接口的关系以及使用案例

推荐阅读