Lambda表达式学习笔记

最新推荐文章于 2021-12-10 21:13:42 发布

run every where

最新推荐文章于 2021-12-10 21:13:42 发布

阅读量129

点赞数

文章标签： java lambda

本文链接：https://blog.csdn.net/m0_47902536/article/details/117389851

版权

本文介绍了Java8中的Lambda表达式，包括其概念、使用原因、用法和优势。Lambda表达式简化了匿名内部类的使用，提高了代码可读性和简洁性。通过一个排序问题的实例，展示了如何利用Lambda进行比较器的定义，进一步阐述了Lambda在实际编程中的实用性。

摘要由CSDN通过智能技术生成

一，Lambda表达式的概念
二，为什么要使用Lambda表达式
三，Lambda的用法
四：不用Lambda表达式和用Lambda表达式的好处

一，Lambda表达式的概念：
1，简述一下Lambda表达式的概念，Lambda表达式是Java8推出的新特性，其实说白了它就是为匿名内部类服务的，所以说，Lambda表达式与匿名内部类有关系，大家刚学匿名内部类的时候是不是感觉那种写法特别别扭，可读性特别差，所以，引入Lambda表达式就是为了简化代码。
2， Lambda表达式又叫做‘函数式接口’。
什么是函数式接口呢？
如果一个接口只有一个抽象方法，那这个接口就是函数式接口。
比如Comparable接口

      public interface Comparable<T> {
              public int compareTo(T o);
}

public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

二，为什么要使用Lambda表达式：
1.使代码可读性变好
2.避免匿名内部类，因为匿名内部类看着很别扭，尽量少出现匿名内部类

三，Lambda的用法

(参数)->语句；

案例:
()->2;//无参数，返回值为2；
(int x,int y)->x+y;//方法有两个参数，返回两个参数的和；

四：不用Lambda表达式和用Lambda表达式的好处

1.采用匿名内部类：

public interface MyInterface {// 定义一个接口
    int sum(int x,int y);
}
class Text{
    public static void main(String[] args) {

        MyInterface m=new MyInterface(){//采用匿名内部类实现接口的方法
          public  int sum(int x,int y){
              System.out.println("两数之和:");
               return x+y;
           }
        };
        System.out.println(m.sum(100,200));

2.也可以定义一个类实现MyInterface接口

public interface MyInterface {
    int sum(int x,int y);
}

class A implements MyInterface{

    @Override
    public int sum(int x, int y) {
        return x+y;
    }
}
class Text{
    public static void main(String[] args) {
        
        A  a=new A();
        a.sum(100,200);

3.采用Lambda表达式：

MyInterface i=(int x,int y)-> x+y;

        System.out.println(i.sum(100,200));

综合三种方法，很显然，采用Lambda表达式，代码看起来非常简洁，可读性增强。

其实，这也体现了面向对象的缺点，面向对象可以使复杂的问题简单化，但是，他也使简单的问题复杂化，如果想用接口的方法，我们必须实现一个接口，才能使用接口的方法，而Lambda表达式可以简化它。

我再分享一个排序的题，
正好可以用一下Lambda表达式

题目描述

传智专修学院总共召集了 nn 位志愿者来负责打扫活动，现在需要你负责帮忙统计每位志愿者的工作情况，用来制作光荣榜，给他们发小花花。

第 ii 位志愿者有一个工作时长 t_it
i

，以及他负责的工作的难度系数 k_ik
i

，一名志愿者的贡献度可以用 k_i \times t_ik
i

×t
i

确定。

现在要为这些志愿者的贡献度从大到小排个序，请你完成这个任务。相同贡献度的志愿者以工作时长较长的排在前面。如果贡献和时长一样，那么编号小的志愿者排在前面。

输入格式
一行一个整数 nn ，表示志愿者的数量。

接下来 nn 行，每行两个使用空格隔开的整数 t_i,k_it
i

,k
i

，表示第 ii 名志愿者的时间和难度系数。

输出格式
一行，共 nn 个整数，第 ii 个数表示排名为 ii 的志愿者的序号，从 11 开始编号。

import java.util.*;
public class 志愿者 {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int num=s.nextInt();
         List<Person> p=new ArrayList();
        for (int i=0;i<num;i++){
            int time=s.nextInt();
            int difficult=s.nextInt();
            p.add(new Person(i+1,time,difficult));
        }
        Comparator<Person> c=(Person o1, Person o2)-> {
            if ((o1.getDifficult() * o1.getTime()) < (o2.getDifficult() * o2.getTime())) {
                return 1;
            }else if ((o1.getDifficult() * o1.getTime()) > (o2.getDifficult() * o2.getTime())){
                return -1;
            }
            if (o1.getTime()  < o2.getTime() ) {
                return 1;
            }else if (o1.getTime()  > o2.getTime() ){
                return -1;
            }
            if ((o1.getDifficult() * o1.getTime()) == (o2.getDifficult() * o2.getTime())
                    && ((o1.getTime() ) == (o2.getTime() ))) {
                if (o1.getNum() > o2.getNum()) {
                    return 1;
                }
            }
            return -1;
        };
       Collections.sort(p,c);
       for (int j=0;j<p.size();j++){
           System.out.print(p.get(j).num+" ");
       }
    }
    }

class Person {
    int num;
    int time;
    int difficult;

    public Person(){

    }

    public Person( int num, int time,int difficult) {
        this.num=num;
        this.time = time;
        this.difficult = difficult;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public int getDifficult() {
        return difficult;
    }

    public void setDifficult(int difficult) {
        this.difficult = difficult;
    }

    public int getTime() {
        return time;
    }

    public void setTime(int time) {
        this.time = time;
    }
}