Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

Lambda表达式---基本使用

DaveM 2019-12-24 00:24:00 阅读数:23 评论数:0 点赞数:0 收藏数:0

什么是lambda表达式?

1.一个匿名函数;

2.对接口的间接实现。

 

 /**
 * 1.lambda -- 一个匿名函数
  * 2.可以对一个接口进行简洁的实现
  * 3.要求接口中定义的抽象方法必须是一个
 */
public class Demo1 {
 public static void main(String[] args) {
 //接口实现类
Comparator comparator = new MyComparator();

//匿名内部类
Comparator comparator2 = new Comparator() {
  @Override
 public int compare(int a, int b) {
 return a - b;
  }
  };

//lambda
Comparator comparator3 = (a,b) -> a - b;
  }
 }

class MyComparator implements Comparator{

 @Override
 public int compare(int a, int b) {
 return a - b;
  }
 }

/**
 * 抽象方法只有一个,修饰函数式接口
 */
@FunctionalInterface
 interface Comparator{
 int compare(int a,int b);
 }

 

几种基本使用形式:

 

 

 public class BasicUse {
 public static void main(String[] args) {
 //() --- 参数列表
 //{} --- 方法体
 // -> --- lambda运算符 goes to
NoReturnAndParam noReturnAndParam = () ->{
 System.out.println("Hello lambda");
  };
  noReturnAndParam.f();

NoReturnSingleParam noReturnSingleParam = (int a) ->{
  System.out.println(a);
  };
 noReturnSingleParam.f(100);
 /**
 * 单个参数可省略括号
  * 且语句只有一条也可省略
 */
NoReturnSingleParam noReturnSingleParam2 = a -> System.out.println(a);

NoReturnMutiParam noReturnMutiParam = (int a,int b) ->{
 System.out.println(a + b);
  };
 noReturnMutiParam.f(10,100);
 /**
 * 接口中定义了参数的类型,参数类型可省略,但是必须全部省略
  * 精简参数类型
 */
NoReturnMutiParam noReturnMutiParam2 = (a,b) ->{
 System.out.println(a + b);
  };

ReturnAndNoParam returnAndNoParam = () -> {
 System.out.println("noParamWithReturn");
 return 10;
  };
 int re = returnAndNoParam.f();
  System.out.println(re);

ReturnAndSingleParam returnAndSingleParam = (int a) ->{
 return a * 100;
  };
 int reParam = returnAndSingleParam.f(20);
  System.out.println(reParam);
 /**
 * 当语句只有一条return时,除了省略大括号还需要省略return
 */
ReturnAndSingleParam returnAndSingleParam2 = a -> a * 10;

ReturnAndMutiParam returnAndMutiParam = (int a,int b) ->{
 return a - b;
  };
 int reParams = returnAndMutiParam.f(100,20);
  System.out.println(reParams);

 }
 }

 

方法引用

 public class MethodUse {
 public static void main(String[] args) {
 //方法引用
/**
 * lambda表达式实现一个已经实现的函数
  * 方法所属者
  * 类/对象
  * 方法参数类型和数量一定要和接口中对应
  * 返回值必须一致
 */
ReturnAndSingleParam returnAndSingleParam = a -> change(a);

ReturnAndSingleParam returnAndSingleParam2 = MethodUse::change;
  }
 private static int change(int a){
 return a * 10;
  }
 }

构造器引用

 public class ConstructorUse {
 public static void main(String[] args) {
 PersonUse personUse = () -> new Person();
 //引用无参构造方法
PersonUse personUse2 = Person::new;
 Person person = personUse2.getPerson();
  System.out.println(person);

//引用有参构造方法
PersonUse2 personUse21 = Person::new;
 Person person21 = personUse21.getPersonWithParam("Dave",26);
  System.out.println(person21);
  }
 }
 interface PersonUse{
  Person getPerson();
 }

interface PersonUse2{
 Person getPersonWithParam(String name,int age);
 }

实例化线程

 public class ThreadUse {
 public static void main(String[] args) {
 /**
 * Runnable接口,无参无返回
 */
Thread t1 = new Thread(() ->{
 for (int i = 0; i < 10 ; i++) {
  System.out.println(i);
  }
  });
  t1.start();
  }
 }

闭包

 public class CloserDemo {
 public static void main(String[] args) {
 int n = getNumber().get();
  System.out.println(n);
  }

/**
 * 闭包 --->获取某个方法中的局部变量
  * 引用某个局部变量--- > 系统默认添加final常量
  * @return
*/
private static Supplier<Integer> getNumber(){
 //提升局部变量的生命周期,在方法结束后仍可以使用
int num =10;
 return () -> {
 return num;
  };
  }
 }
版权声明
本文为[DaveM]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/DaveMo/p/12089235.html