概述
文章目录
- 内部类
- 内部类
- 匿名内部类
- Lambda表达式：实现函数式接口
- Lambda 表达式的结
- 函数式接口匹配Lambda表达式
- Lambda表达式 vs 匿名接口实现
- Lambda类型推断
- Lambda参数
- 无参数
- 一个参数
- 多个参数
- 指定参数类型
- Lambda表达式主体
- Lambda表达式返回值
- Lambdas作为对象
- Lambda方法引用
- 静态方法引用
- 参数方法引用: 引用第一个参数的方法，其余参数作为方法入参传入
- 实例方法引用
- 构造方法引用
- Java8四大内置函数式接口
- 1、Consumer 消费性接口：void accept(T t)；
- 2、Supplier供给型接口： T get();
- 3、Function 函数式接口：R apply(T t);
- 4、Predicate 断言式接口：boolean test(T t);
内部类
内部类
匿名内部类
Java匿名类，Java匿名内部类 (biancheng.net)
匿名类是一个表达式，匿名类的语法就类似于调用一个类的构建函数（new HelloWorld()），除些之外，还包含了一个代码块，在代码块中完成类的定义。主要针对接口类和抽象类，对于普通类可直接new实例，匿名构造就没有意义。
匿名内部类主要用来对接口或抽象类进行一次性的实例化实现
实现接口，不必传入参数，只需实现接口方法
实现抽象类，可根据抽象类不同构造方法来传入必要的参数，同时可以重写抽象类方法
使用目的：匿名内部类这一语法适用于创建一次性使用的类。
使用前提：存在抽象类或接口带实现
语法格式为：
new 实现接口() | **父类构造器 (实参列表)**{
//匿名内部类的类体部分
}
从这一定义可以看出，使用匿名内部类需要注意两点：
匿名内部类不能为抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的实例。
匿名内部类无法定义构造器。因为匿名内部类不存在类名，所以也就无从定义构造器。不过也可以通过定义初始化块来完成构造器需要完成的工作。
而最常见的匿名内部类的应用场合为： 需要通过实现接口来创建匿名内部类。
举个例子：
interface ProductInformationList {
int getNumber();
String getName();
}
public class AnonymousClassTest{
public void test (ProductInformationList pil) {
System.out.println("产品数量是： "+
pil.getNumber()+"产品名称是 "+pil.getName());
}
public static void main(String[] args) {
AnonymousClassTest ac = new AnonymousClassTest();
//调用test()方法，需要传入一个ProductInformationList参数
//此处传入其匿名实现类的实例
ac.test(new ProductInformationList()
{
public int getNumber()
{
return 4;
}
public String getName()
{
return "电脑";
}
});
}
}
如果这个接口实现类的对象会被重复使用的话，则可以将此实现类定义为一个独立的类；
但是现在只需要使用一次，所以就采用上述方法，定义一个匿名内部类。
因为匿名内部类不能是抽象类，所以必须要实现抽象父类或者接口中定义的全部抽象方法。
如果通过实现接口来创建匿名内部类，匿名内部类不能显式地创建构造器，所以匿名内部类只能有一个隐式的无参构造器。也就是说，new接口名后的括号里不能传入参数。
但是，如果是通过继承抽象父类来创建匿名内部类，则有：匿名内部类将拥有和父类拥有相同行参列表的构造器。
举个例子：
abstract class Person{
private String name;
public abstract double getHeight();
//父类的构造器
public Person(){}
public Person(String name){
this.name = name;
}
//私有成员变量name的setter和getter方法
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}
public class AnonyousInnerTest{
public void test (Person p){
//%f表示格式化输出浮点数，.2表示保留到小数点后两位
//%s对应字符串
//%n表示换行
System.out.printf("姓名为%s;%n身高为%.2f;%n",
p.getName(),p.getHeight());
}
public static void main(String[] args) {
AnonyousInnerTest ait = new AnonyousInnerTest();
//调用有参数的构造器创建Person匿名实现类的对象
ait.test(new Person("图灵")
{
//实现抽象父类的抽象方法
public double getHeight(){
return 180.2;
}
});
//调用无参构造器创建Person匿名实现类的对象
Person p = new Person()
{
//初始化块
{
System.out.println(".........分割线.........");
System.out.println("匿名内部类的初始化块。。。");
}
//实现抽象方法
public double getHeight(){
return 170.4;
}
//重写父类实例方法
public String getName(){
return "人工智能";
}
};
ait.test(p);
}
}
也就是说，创建匿名内部类时，必须实现接口或抽象父类中的所有抽象方法。
另外，如果有必要的话，也可以重写父类中的普通方法
匿名类有如下特点：
1）匿名类和局部内部类一样，可以访问外部类的所有成员。如果匿名类位于一个方法中，则匿名类只能访问方法中 final 类型的局部变量和参数。
public static void main(String[] args) {
int a = 10;
final int b = 10;
Out anonyInter = new Out() {
void show() {
// System.out.println("调用了匿名类的 show() 方法"+a); // 编译出错
System.out.println("调用了匿名类的 show() 方法"+b); // 编译通过
}
};
anonyInter.show();
}
注意，若使用JDK1.8，方法中内部类的方法是可以直接访问外部类的方法的局部变量，并且不需要声明为final类型。
2）匿名类中允许使用非静态代码块进行成员初始化操作。
3）匿名类的非静态代码块会在父类的构造方法之后被执行。
匿名内部类的格式和理解
A：匿名内部类
就是内部类的简化写法。
B：前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
匿名内部类，意思就是没有名字。没有名字就需要想办法表示它。
怎么表示它呢？就是要实现一个接口或者继承一个类。
必须要和外面的某个接口或者某个类产生关系，这才是匿名内部类。
C：格式
new 类名或者接口名(){
重写方法;
}
D：本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。
Lambda表达式：实现函数式接口
参考文献：https://www.cnblogs.com/three-fighter/p/13326627.html#java-lambdas%E5%92%8C%E5%87%BD%E6%95%B0%E5%BC%8F%E6%8E%A5%E5%8F%A3
函数式接口：
只定义了一个待实现方法的接口称为函数式接口
Lambda 表达式的结
(arg1, arg2...) -> { body }
- 一个 Lambda 表达式可以有零个或多个参数
- 参数的类型既可以明确声明，也可以根据上下文来推断。例如：
(int a)与(a)效果相同 - 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：
(a, b)或(int a, int b)或(String a, int b, float c) - 空圆括号代表参数集为空。例如：
() -> 42 - 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：
a -> return a*a - Lambda 表达式的主体可包含零条或多条语句
- 如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
- 如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空
函数式接口匹配Lambda表达式
单个抽象方法接口有时也称为函数式接口。@FunctionalInterface 是 Java 8 新加入的一种注解，用于指明该接口类型声明是根据 Java 语言规范定义的函数式接口
将Java lambda表达式与函数式接口进行匹配需要以下步骤：
- 接口是否只有一个抽象方法？
- lambda表达式的参数是否与抽象方法的参数匹配？
- lambda表达式的返回类型是否与抽象方法的返回类型匹配？
如果这三个条件都满足，则该接口可以匹配给定的lambda表达式。
从Java 8开始，Java接口可以包含默认方法和静态方法。默认方法和静态方法都可以在接口中直接实现。这意味着，Java lambda表达式可以实现带有默认方法和静态方法的接口——只要该接口仅有一个抽象方法即可。
Lambda表达式 vs 匿名接口实现
即使lambda表达式接近匿名接口实现，但也有一些区别需要注意。
最主要的区别，匿名接口实现可以具有状态（成员变量），而lambda表达式则不能。
看一下下面这个接口：
public interface MyEventConsumer {
public void consume(Object event);
}
可以使用匿名接口实现方式来实现此接口，如下所示：
MyEventConsumer consumer = new MyEventConsumer() {
public void consume(Object event){
System.out.println(event.toString() + " consumed");
}
};
此匿名MyEventConsumer实现可以具有自己的内部状态。
重写匿名接口实现：
MyEventConsumer myEventConsumer = new MyEventConsumer() {
private int eventCount = 0;
public void consume(Object event) {
System.out.println(event.toString() + " consumed " + this.eventCount++ + " times.");
}
};
请注意，匿名MyEventConsumer接口实现现在具有一个名为eventCount的属性。
Lambda表达式不能具有此类属性。因此，lambda表达式是无状态的。
Lambda类型推断
在Java 8之前，在进行匿名接口实现时，必须指定要实现的接口。这是本文开头的匿名接口实现示例：
stateOwner.addStateListener(new StateChangeListener() {
public void onStateChange(State oldState, State newState) {
*// do something with the old and new state.*
}
});
使用lambda表达式时，通常可以从相关的代码中推断出类型。例如，可以从addStateListener()方法（StateChangeListener接口上的抽象方法）的方法声明中推断参数的接口类型。
这称为类型推断。编译器通过在其他地方寻找类型来推断参数的类型——在这种情况下为方法定义。这是本文开头的示例，lambda表达式中并未声明参数的类型：
stateOwner.addStateListener(
(oldState, newState) -> System.out.println("State changed")
);
在lambda表达式中，通常可以推断参数类型。在上面的示例中，编译器可以从onStateChange()方法声明中推断其类型。因此，从onStateChange()方法的方法声明中就可以推断出参数 oldState 和 newState 的类型。
Lambda参数
无参数
如果lambda表达式匹配的方法无参数，则可以这样写lambda表达式：
() -> System.out.println("Zero parameter lambda");
请注意，括号中没有内容。那就是表示lambda不带任何参数。
一个参数
如果Java lambda表达式匹配的方法有一个参数，则可以这样写lambda表达式：
(param) -> System.out.println("One parameter: " + param);
请注意，参数在括号内列出。
当lambda表达式是单个参数时，也可以省略括号，如下所示：
param -> System.out.println("One parameter: " + param);
多个参数
如果Java lambda表达式匹配的方法有多个参数，则需要在括号内列出这些参数。代码如下：
(p1, p2) -> System.out.println("Multiple parameters: " + p1 + ", " + p2);
仅当方法是单个参数时，才可以省略括号。
指定参数类型
如果编译器无法从lambda匹配的函数式接口抽象方法推断参数类型，则有时可能需要为lambda表达式指定参数类型。不用担心，编译器会在这种情况下会有提醒。这是一个Java lambda指定参数类型示例：
(Car car) -> System.out.println("The car is: " + car.getName());
如你所见，car参数的类型（Car）写在参数名称的前面，就像在其他方法中声明参数或对接口进行匿名实现时一样。
Lambda表达式主体
lambda表达式的主体以及它表示的函数/方法的主体在lambda声明中的->的右侧指定：
这是一个示例：
(oldState, newState) -> System.out.println("State changed")
如果你的lambda表达式需要包含多行，则可以将lambda函数主体括在{}括号内，Java在其他地方声明方法时也需要将其括起来。这是一个例子：
(oldState, newState) -> {
System.out.println("Old state: " + oldState);
System.out.println("New state: " + newState);
}
Lambda表达式返回值
你可以从Java lambda表达式返回值，就像从方法中返回值一样。你只需向lambda表达式主体添加一个return，如下所示：
(param) -> {
System.out.println("param: " + param);
return "return value";
}
如果你的lambda表达式只需要计算一个返回值并将其返回，则可以用更短的方式指定返回值。例如这个：
(a1, a2) -> { return a1 > a2; }
你可以写成：
(a1, a2) -> a1 > a2;
然后，编译器会断定表达式 a1> a2 是lambda表达式的返回值。
Lambdas作为对象
Java lambda表达式本质上是一个对象。你可以将变量指向lambda表达式并传递，就像处理其他任何对象一样。这是一个例子：
public interface MyComparator {
public boolean compare(int a1, int a2);
}
MyComparator myComparator = (a1, a2) -> return a1 > a2;
boolean result = myComparator.compare(2, 5);
第一个代码块显示了lambda表达式实现的接口。
第二个代码块显示了lambda表达式的定义，lambda表达式如何分配给变量，以及最后如何通过调用其实现的接口方法来调用lambda表达式。
Lambda方法引用
参考文献：https://zq99299.github.io/java-tutorial/java/javaoo/methodreferences.html#%E6%96%B9%E6%B3%95%E5%BC%95%E7%94%A8%E7%9A%84%E6%96%B9%E5%BC%8F
方法引用：如果你的lambda表达式所做的只是用传递给lambda的参数调用另一个方法，则Java lambda实现提供了更简洁的方式表示该方法调用。
首先，这是一个函数式接口：
public interface MyPrinter{
public void print(String s);
}
以下是创建实现MyPrinter接口的Java lambda表达式的示例：
MyPrinter myPrinter = (s) -> { System.out.println(s); };
由于lambda主体仅由一个语句组成，因此我们实际上可以省略括号{}。另外，由于lambda方法只有一个参数，因此我们可以省略该参数周围的括号()。更改之后的lambda表达式：
MyPrinter myPrinter = s -> System.out.println(s);
由于所有lambda主体所做的工作都是将字符串参数转发给System.out.println()方法，因此我们可以将上述lambda声明替换为方法引用。以下是lambda表达式引用方法的实例：
MyPrinter myPrinter = System.out::println;
注意双冒号::。它会向Java编译器发出信号，这是方法引用。引用的方法是双冒号之后的内容。拥有被引用方法的任何类或对象都在双冒号之前。
lambda 表达式创建匿名方法。然而，有时，lambda 表达式只能调用现有方法。在这些情况下，通过名称来引用现有的方法往往更为清楚。方法引用使您能够做到这一点; 对于已经有名称的方法，它们是紧凑的，易于阅读的 lambda 表达式
你可以引用以下类型的方法：
- 静态方法
- 参数对象的实例方法
- 实例方法
- 构造方法
静态方法引用
最容易引用的方法是静态方法。
首先是函数式接口的示例：
public interface Finder {
public int find(String s1, String s2);
}
这是一个静态方法：
public class MyClass{
public static int doFind(String s1, String s2){
return s1.lastIndexOf(s2);
}
}
最后是引用静态方法的Java lambda表达式：
Finder finder = MyClass::doFind;
由于Finder.find()和MyClass.doFind()方法的参数匹配，因此可以创建实现Finder.find()并引用MyClass.doFind()方法的lambda表达式。
参数方法引用: 引用第一个参数的方法，其余参数作为方法入参传入
也可以将其中一个参数的方法引用到lambda。
函数式接口如下：
public interface Finder {
public int find(String s1, String s2);
}
该接口用于表示能在s1中搜索s2的出现的部分。下面是一个Java lambda表达式的示例，它调用indexOf() 搜索：
Finder finder = String::indexOf;
这等价以下lambda定义：
Finder finder = (s1, s2) -> s1.indexOf(s2);
Java编译器尝试将引用的方法与第一个参数类型相匹配，使用第二个参数类型作为被引用方法的参数。
实例方法引用
第三，还可以从lambda表达式中引用实例方法。
首先，让我们来看一个函数式接口定义：
public interface Deserializer {
public int deserialize(String v1);
}
此接口表示一个组件，该组件能够将字符串“反序列化”为int。
现在看看这个StringConverter类：
public class StringConverter {
public int convertToInt(String v1){
return Integer.valueOf(v1);
}
}
convertToInt()方法与Deserializer deserialize()方法的deserialize()方法具有相同的签名。因此，我们可以创建StringConverter的实例，并从Java lambda表达式引用其convertToInt()方法，如下所示：
StringConverter stringConverter = new StringConverter();
Deserializer des = stringConverter::convertToInt;
第二行创建的lambda表达式引用在第一行创建的StringConverter实例的convertToInt方法。
构造方法引用
最后，可以引用一个类的构造方法。你可以通过在类名后加上:: new来完成此操作，如下所示：
MyClass::new
来看看如何在lambda表达式中引用构造方法。
函数式接口定义如下：
public interface Factory {
public String create(char[] val);
}
此接口的create()方法与String类中某个构造函数的签名匹配。因此，此构造函数可以被lambda表达式用到。下面是一个示例：
Factory factory = String::new;
等同于如下lambda表达式：
Factory factory = chars -> new String(chars);
Java8四大内置函数式接口
1、Consumer 消费性接口：void accept(T t)；
//有一个参数，并且无返回值
public static void test3() {
//这个e就代表所实现的接口的方法的参数，
Consumer<String> consumer = e->System.out.println("Lambda 表达式方式，"+e);
consumer.accept("传入参数");
}
2、Supplier供给型接口： T get();
package javase.Lambda;
import java.util.ArrayList;
import java.util.function.Supplier;
public class Test2 {
public static void main(String[] args) {
ArrayList<Integer> res = getNumList(10,()->(int)(Math.random()*100));
System.out.println(res);
}
public static ArrayList<Integer> getNumList(int num, Supplier<Integer> sup){
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
Integer e = sup.get();
list.add(e);
}
return list;
}
}
3、Function 函数式接口：R apply(T t);
package javase.Lambda;
import java.util.function.Function;
public class Test2 {
public static void main(String[] args) {
String newStr = strHandler("abc",(str)->str.toUpperCase());
System.out.println(newStr);
newStr = strHandler(" abc ",(str)->str.trim());
System.out.println(newStr);
}
public static String strHandler(String str, Function<String,String>fun){
return fun.apply(str);
}
}
4、Predicate 断言式接口：boolean test(T t);
package javase.Lambda;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Test2 {
public static void main(String[] args) {
List<String> list = Arrays.asList("hello","jiangshuying","lambda","www","ok","q");
List<String> ret = filterStr(list,(str)->str.length()>2);
System.out.println(ret);
}
public static List<String> filterStr(List<String> list, Predicate<String> pre){
ArrayList<String> arrayList = new ArrayList<>();
for(String str:list){
if(pre.test(str)) {
arrayList.add(str);
}
}
return arrayList;
}
}
最后
以上就是成就期待为你收集整理的Java中Lambda表达式与方法引用内部类Lambda表达式：实现函数式接口Lambda 表达式的结函数式接口匹配Lambda表达式Lambda表达式 vs 匿名接口实现Lambda类型推断Lambda参数Lambda表达式主体Lambda表达式返回值Lambdas作为对象Lambda方法引用Java8四大内置函数式接口的全部内容，希望文章能够帮你解决Java中Lambda表达式与方法引用内部类Lambda表达式：实现函数式接口Lambda 表达式的结函数式接口匹配Lambda表达式Lambda表达式 vs 匿名接口实现Lambda类型推断Lambda参数Lambda表达式主体Lambda表达式返回值Lambdas作为对象Lambda方法引用Java8四大内置函数式接口所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复