Lambda-让人又爱又恨的“->＂ Lambda-让人又爱又恨的“-

写在前边

聊到Java8新特性，我们第一反应想到的肯定是Lambda表达式和函数式接口的出现。要说ta到底有没有在一定程度上“优化”了代码的简洁性呢？抑或是ta在一定程度上给程序员增加了阅读和debug的难度，让不少程序员头疼。这期来接着“聊聊Java”，新特性篇只又爱又恨的Lambda。

Lambda表达式

实质属于函数式编程的概念,可返回一个接口的实现

线程中的应用

文章图片
"_第1张图片" width="592" height="203" style="border:1px solid black; ">
传统方式
创建一个一次性的类

//一次性的类,用在new Thread中充当Runnable对的实现类 class runnable implements Runnable{@Override public void run() { System.out.println("我在路上"); } }public class lambdaTest { public static void main(String[] args) { runnable runnable = new runnable(); Thread thread1 = new Thread(runnable); } }

(稍微优化)匿名内部类

Thread thread1 = new Thread(new Runnable() { @Override public void run() { System.out.println("我在路上"); } });

作用

避免匿名内部类定义过多
使代码看起来简洁
简化代码，只留下核心逻辑

函数式接口

定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

public interface Runnable{ void run(); }

为了避免后来人给这个接口添加函数后,导致该接口有多个函数,不再是函数式接口,我们可以在接口类的上方声明@FunctionalInterface

文章图片
"_第2张图片" width="484" height="237" style="border:1px solid black; ">
所有的Lambda的类型都是一个接口

而Lambda表达式本身，就是这个接口的实现

文章图片
"_第3张图片" width="559" height="288" style="border:1px solid black; ">
如果定义成实现类,就会报错

我们在程序编译的时候并不知道我们最终创建出来的对象具体是哪个子类,直到运行时期才能得知,随之我们可以让这个like指向指向各种不同的类上,可以调用各种不同的子类方法,大大提高了程序的可扩展性

而这里我们用lambda实际上是等价于匿名内部类(没有类名),实际创建出来的类是什么,我们不知道,所以我们会定义成接口,利用多态的向上转型特性
关于多态的更多特性,在我的另一篇博客中 : 传送门-> 多态

文章图片
"_第4张图片" width="650" height="208" style="border:1px solid black; ">

文章图片

方法引用 Demo

//接口定义 interface parseIntNum{ //定义一个String转化成Integer的方法 int pass(String s); } public static void main(String[] args) { parseIntNum parseIntNum1; parseIntNum parseIntNum2; //原始lambda parseIntNum1 = (str)-> Integer.parseInt(str); System.out.println(parseIntNum1.pass("1")); //方法引用改进版本 parseIntNum2 = Integer::parseInt; System.out.println(parseIntNum2.pass("1")); }

文章图片

所谓方法引用，是指如果某个已经存在的方法,他的签名和接口里边定义的函数恰好一致，就可以直接传入方法引用。
因为parseIntNum接口定义的方法是int pass(String s)，和Integer中的静态方法int parseInt(String s)相比，除了方法名外，方法参数一致，返回类型相同，这就是我们说的方法签名一致，可以直接传入方法引用
方法引用的写法

其实很简单,只需要使用操作符双冒号** "::"**

常见的方法引用

文章图片
"_第5张图片" width="650" height="293" style="border:1px solid black; ">
常见的引用形式类名::静态方法名

调用类的静态方法

其实我们上边使用Integer::parseInt 就等价于调用 Integer的静态方法 parseInt

文章图片

对象:实例方法

此处小小中二了一点hhhh

class Naruto{ public static void Rasengan(){ System.out.println("螺旋丸"); } } //接口定义 interface Ninja{ //定义一个奥义方法 void aoyi(); } public class methodQuote { //通过引用Naurto的螺旋丸 Ninja ninja=Naruto::Rasengan; //再发动奥义 ninjia.aoyi(); }

数据类型:new

public static void main(String[] args) { //方式一 IntFunction arr1 = new IntFunction() { @Override public int[] apply(int num) { return new int[num]; } }; arr1.apply(10); //方式二(方法引用) IntFunction arr2 = int[]::new; arr2.apply(10); }

除此之外还有很多种形式,这里就不过多赘述了

开发常用常用小技巧:遍历数组打印对比三种方法,可以看出简洁程度

ArrayList arrayList=new ArrayList<>(); arrayList.add(1); arrayList.add(2); arrayList.add(3); //匿名内部类 arrayList.forEach(new Consumer() { @Override public void accept(Integer integer) { System.out.println(integer); } }); //lambda优化 arrayList.forEach((integer)-> System.out.println(integer)); //方法引用打印,用方法引用替代了我们的匿名内部类(相当于替代了lambda) arrayList.forEach(System.out::println);

遍历Map

Map map = new HashMap<>(); map.forEach((k,v)->System.out.println(v));

Lambda表达式作用域访问局部普通变量

只能引用标记了final的外层局部变量

即 : 不能在lambda 内部修改定义在域外的局部变量，否则会编译错误。

文章图片
"_第6张图片" width="650" height="254" style="border:1px solid black; ">

特殊情况下，局部变量也可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

文章图片
"_第7张图片" width="650" height="235" style="border:1px solid black; ">
破坏隐式final(再次修改)

文章图片
"_第8张图片" width="650" height="277" style="border:1px solid black; ">

package com.melo.notes.lambdaTest; public class TestFinal { interface MeiYan{ Integer change(String str); }public static void main(String[] args) { //定义局部变量 String temp = "222"; //写成一行可以不用return MeiYan meiYan = (str -> Integer.valueOf(str+temp)); //再次修改,不符合隐式final定义 temp = "333"; Integer str =meiYan.change("111") ; System.out.println(str); } }

不允许声明一个与局部变量同名的参数或者局部变量。

访问局部引用变量

文章图片
"_第9张图片" width="650" height="291" style="border:1px solid black; ">

import java.util.ArrayList; public class TestArray {interface MeiYan{ Integer change(); } void testArrayList(){ ArrayList list = new ArrayList<>(); list.add("111"); //访问外部引用局部引用变量 MeiYan meiYan = (() -> Integer.valueOf(list.get(0))); //修改局部引用变量 list.set(0,"222"); Integer str =meiYan.change(); System.out.println(str); } public static void main(String[] args) { new TestArray().testArrayList(); } }

访问引用变量的话，是没有问题的。因为lambda可以感知到外部对该引用变量的改变，不会出现数据不同步问题

具体可以看下边的"理解"有更详细的解释

访问静态变量和实例变量

都是可以的，再次修改也不会报错

文章图片
"_第10张图片" width="650" height="474" style="border:1px solid black; ">
代码

public class TestFinal { //静态变量 static String StaticTemp; //实例变量 String instanceTemp; interface MeiYan{ Integer change(String str); } void testStatic(){ StaticTemp="222"; MeiYan meiYan = (str -> Integer.valueOf(str+StaticTemp)); StaticTemp="333"; Integer str =meiYan.change("111") ; System.out.println(str); } public static void main(String[] args) { new TestFinal().testStatic(); }

理解实例变量和局部变量的区别
这里的关键问题转换到: 实例变量和局部变量的区别是什么?