目录
  • 理解函数式接口以及 lambda表达式的发展过程
  • lambda表达式及语法
  • lambda的实际运用
    • 4.代替 runnable,开启一个线程

理解函数式接口以及 lambda表达式的发展过程

任何接口,只包含唯一一个抽象方法,就是函数式接口

/**
 * lambdab表达式的发展
 */
public class testlambda1 {
    //3.静态内部类
    static class like2 implements ilike{
        @override
        public void lambda() {
            system.out.println("i like lambda2");
        }
    }

    public static void main(string[] args) {
        ilike like=new like();
        like.lambda();

        like=new like2();
        like.lambda();

        //4.局部内部类
       class like3 implements ilike{
            @override
            public void lambda() {
                system.out.println("i like lambda3");
            }
        }
        like=new like3();
        like.lambda();

        //5.匿名内部类
        like=new ilike() {
            @override
            public void lambda() {
                system.out.println("i like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化
        like=()->{
            system.out.println("i like lambda5");
        };
        like.lambda();
    }
}

//1.定义一个函数式接口
interface ilike{
    void lambda();
}

//2.实现类
class like implements ilike{

    @override
    public void lambda() {
        system.out.println("i like lambda");
    }
}

lambda表达式及语法

lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(string s) -> system.out.print(s)

也就是说,不需要事先声明参数的类型,圆括号可以没有,大括号可以没有,返回值可以没有

一起来看看具体的使用

public class java8_lambda_test {
    public static final void main(string[] args) {

        operator addoper = (a, b) -> a + b;
        operator reduceoper = (a, b) -> a - b;
        operator multiplyoper = (a, b) -> a * b;
        operator divideoper = (a, b) -> a / b;

        java8_lambda_test test = new java8_lambda_test();
        system.out.println(test.getresult(3, 3, addoper));//6
        system.out.println(test.getresult(3, 3, reduceoper));//0
        system.out.println(test.getresult(3, 3, multiplyoper));//9
        system.out.println(test.getresult(3, 3, divideoper));//1
    }

    public int getresult(int a, int b, operator operator) {
        return operator.convert(a, b);
    }

    public interface operator {
        int convert(int a, int b);
        default int get(int a) {
            return a;
        }
    }
}

你需要注意什么

1.lambda 表达式只能引用标记了 final 的外层局部变量
2.可以直接在 lambda 表达式中访问外层的局部变量

lambda的实际运用

1.对集合排序

问题描述:在一个存放了student对象的list中,按年龄进行排序,输出排序后的list

student类

public class student implements comparable<student>{
    private string name;
    private int age;

    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;
    }

    @override
    public int compareto(student student2) {
       int result =this.age - student2.age;
       return result;
    }
}
        list<student> list=new arraylist<>();
        student s1=new student();
        s1.setname("张三");
        s1.setage(28);
        list.add(s1);
        student s=new student();
        s.setname("李四");
        s.setage(22);
        list.add(s);
        sortusingjava8(list);

        list.foreach((student) -> system.out.println(student.getname() + ":"+student.getage()));
 // 使用 java 8 排序
    static void sortusingjava8(list<student> list){
        collections.sort(list, (student1, student2) -> student1.compareto(student2));
    }

来康康使用java7进行排序是这样的:

    // 使用 java 7 排序
    private void sortusingjava7(list<string> list){
        collections.sort(list, new comparator<string>() {
           @override
           public int compare(string s1, string s2) {
                return s1.compareto(s2);
            }
        });
    }

2.遍历集合

//先准备一个集合
        list<student> list=new arraylist<>();
        student s1=new student();
        s1.setname("张三");
        s1.setage(28);
        list.add(s1);
        student s=new student();
        s.setname("李四");
        s.setage(22);
        list.add(s);
//使用 lambda 表达式以及函数操作(functional operation)
  list.foreach((student) -> system.out.println(student.getname() + ":"+student.getage()));

3.遍历集合(带条件)

 //带条件 打印年龄大于等于20的学生的姓名
        list.foreach((student)->{
            if (student.getage()>=20)
                system.out.println(student.getname());
                });

4.代替 runnable,开启一个线程

runnable r = new runnable() {
    @override
    public void run() {
        //to do something
    }
};
thread t = new thread(r);
t.start();

现在这样写:

runnable r = () -> {
    //to do something
};
thread t = new thread(r);
t.start();

你还可以这样写:

thread t = new thread(() -> {
    //to do something
    // such as for
    for(int i = 0; i < 100; i++){
        system.out.println(i);
           }
});
t.start;

到此这篇关于java中lambda表达式的使用详解的文章就介绍到这了,更多相关java lambda内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com!