lambda与方法引用-20210827

哈喽,大家好,我是指北君。

虽然目前Java最新版本都已经到16了,但是绝大部分公司目前用的Java版本都是8,想当初Java8问世后,其Lambda表达式与方法引用可是最亮眼的新特性,目前,这两个特性也被大家广泛使用,所以今天指北君就带大家看看这两个特性

1.Lambda

从JDK1.8开始为了简化使用者进行代码开发,专门提供有Lambda表达式的支持,利用此操作形式可以实现函数式的编程,对于函数式编程比较著名的语言:haskell,Scala,利用函数式的编程可以避免掉面向对象编程之中的一些繁琐的问题。 面向对象在其长期发展的过程中一直有一部分的反对者认为面向对象过于繁琐

比如:

1
2
3
1
2
3
public interface IMessage {
    public void send(String str);
}
1
2
3
4
5
6
7
8
9
10
11
public class Demo {
    public static void  main(String args[]){
        IMessage msg = new IMessage() {
            @Override
            public void send(String str) {
                System.out.println("消息发送:"+str);
            }
        };
        msg.send("hahahaha");
    }
}

上面语句的核心功能只有一行核心语句,但是为了这一行核心语句依然需要按照完整的面向对象给出的设计结构进行开发。所以Lambda出现啦。

1
2
3
1
2
3
public interface IMessage {
    public void send(String str);
}
1
2
3
4
5
6
7
8
public class Demo {
    public static void  main(String args[]){
       IMessage msg = (str)->{
           System.out.println("发送消息:"+str);
       };
        msg.send("hahahaha");
    }
}

简单吧,这种形式就避免了复杂的面向对象结构化的要求。

Lambda表达式如果要想使用,那么必须有一个重要的实现要求:SAM(Single Abstract Method)只有一个抽象方法(但可以有default和static方法),以IMessage接口为例,在这个接口里面发现只是提供有一个send()方法,除此之外没有任何其他方法定义,所以这样的接口就被称为函数式接口,而只有函数式接口才可以被Lambda表达式所使用

jdk1.8之后可以在接口里面定义static方法和default方法也是为了函数式编程而设置的,如下面这个是允许的

1
2
3
4
5
6
7
public interface IMessage {
    public void send(String str);
    public default void defaultMethod(){
        System.out.println("hahahaha");
    };

}
1
2
3
4
5
6
7
8
9
public class Demo {
    public static void  main(String args[]){
       IMessage msg = (str)->{
           System.out.println("发送消息:"+str);
       };
        msg.send("hahahaha");
        msg.defaultMethod();
    }
}

对于Lambda表达式而言,提供了如下几种格式

1) 方法没有参数:()–>{ };

2) 方法有参数:(参数,参数)–>{ };

3) 如果现在只有一行语句返回:(参数,参数)–>语句;

我们看下第三种

1
2
3
public interface IMath {
    public int add(int x,int y);
}
1
2
3
4
5
6
public class Demo {
    public static void  main(String args[]){
       IMath math = (t1,t2) -> t1 + t2;
        System.out.println(math.add(10,20));
    }
}

利用Lambda表达式可以使代码更加简便

其中一个很经典的应用就是多线程Runnable接口的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Test{
    public static void main(String[] args) {
        /*
        匿名内部类的方式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("nihao");
            }
        }).start();
        System.out.println("你好");
        
        */
        
        
        //lambda的方式
        new Thread(()-> {
            for(int i = 1 ; i<100 ; i++){
                System.out.println("It is a lambda function!");
            }

        }).start();

    }
}

2.方法引用

引用数据类型最大的特点是可以进行内存的指向处理,但是在传统的开发之中一直所使用的只是对象引用操作,而jdk1.8以后也提供有方法的引用,即:不同的方法名称可以描述同一个方法(即可以为一个方法定义多个名字,但是要求必须是函数式接口)。如果要进行方法的引用在java里面提供了如下的四种形式

1)引用静态方法: 类名称 :: static方法名称;

2)引用某个实例对象的方法: 实例化对象 :: 普通方法;

3)引用特定类型的方法: 特定类 :: 普通方法;

4)引用构造方法: 类名称 :: new ;

2.1 引用静态方法

在String类里面提供有String.valueOf( )方法,这个方法就属于静态方法。

方法范例:public static String valueOf(int i),该方法有参数还有返回值

1
2
3
4
@FunctionalInterface  //函数式接口
public interface IFunction<P,R> {
    public R change(P p);      //p描述的是参数,R描述的是返回值
}
1
2
3
4
5
6
7
8
public class Demo {
    public static void  main(String args[]){

        IFunction<Integer , String > fun = String :: valueOf;
        String str = fun.change(100);
        System.out.println(str.length());
    }
}

输出结果为:3

2.2 引用某个实例对象的方法

String类里面有个转大写的方法: public String toUpperCase( )

这个方法是必须在有实例化对象提供的情况下才可以调用

1
2
3
4
@FunctionalInterface  //函数式接口
public interface IFunction<R> {
    public R upper();
}
1
2
3
4
5
6
7
public class Demo {
    public static void  main(String args[]){

        IFunction<String> fun = "hahaha" :: toUpperCase;    //"hahaha"为String的实例化对象
        System.out.println(fun.upper());
    }
}

输出结果为:hahaha

2.3 引用特定类型的方法

在方法引用时也可以引用特定类中的一些操作方法,在String里面提供有一个字符串大小关系的比较

比较大小:public int compareTo(String anotherString)

这是一个普通方法,如果要引用普通方法,则往往都需要实例化对象,但是如果说现在你不想给出实例化对象,只是想引用这个方法,则就可以使用特定类来进行引用处理。

1
2
3
4
@FunctionalInterface  //函数式接口
public interface IFunction<P> {
    public int compare(P p1,P p2);
}
1
2
3
4
5
6
7
public class Demo {
    public static void  main(String args[]){

        IFunction<String> fun = String :: compareTo ;    //String类中的conpareTo方法
        System.out.println(fun.compare("A","a"));
    }
}

输出结果为:-34

2.4 引用构造方法

1
2
3
4
5
6
7
8
9
10
11
public class Person {
    private String name;
    private int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return "姓名:" + this.name + "、年级:" + this.age ;
    }
}
1
2
3
4
@FunctionalInterface  //函数式接口
public interface IFunction<R> {
    public R create(String s ,int a);
}
1
2
3
4
5
6
7
public class Demo {
    public static void  main(String args[]){

        IFunction<Person> fun = Person :: new ;    //String类中的conpareTo方法
        System.out.println(fun.create("张三",20));
    }
}

输出结果:姓名:张三、年级:20

提供方法引用的概念更多情况下也只是弥补了对于引用的支持功能。

3 小结

本文介绍了Java8的新特性,lambda和方法引用,其为我们编程带来了便利,所以我们应该需要掌握它。

我是指北君,操千曲而后晓声,观千剑而后识器。感谢各位人才的:点赞、收藏和评论,我们下期更精彩!

Java Geek Tech wechat
欢迎订阅 Java 技术指北,这里分享关于 Java 的一切。