当前位置：首页 > news >正文

从匿名内部类到Lambda表达式：Java编程的优雅进化

news 来源：原创 2025/5/2 19:48:48

匿名内部类

首先我们先来介绍一下什么是匿名内部类

匿名内部类：java中一种特殊的类定义方式，它允许你在需要实现一个接口或继承一个类的地方直接定义一个该接口或类的匿名子类。若想创建一个派生类的对象，并且对象只创建一次，可以设计为匿名内部类，可以大大简化代码

注意：匿名内部类中不能修改外面局部变量的值

问：内部类有独立的.class吗?

答：有

让我们一起看看代码实例

package ooday04;
 public class AnonInnerClassDemo {
    public static void main(String[] args) {
        //1)创建了Inter的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o1，向上造型为Inter类型
        //  ----new Inter(){};是在创建Inter的派生类的对象
        //3)大括号中的为派生类的类体
        Inter o1 = new Inter(){};
        //1)创建了Inter的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o2，向上造型为Inter类型
        //3)大括号中的为派生类的类体
        Inter o2 = new Inter(){};
        int num = 5;
        num = 6;
        //1)创建了InterInter的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o3，向上造型为InterInter类型
        //3)大括号中的为派生类的类体
        InterInter o3 = new InterInter(){
            public void show(){
                System.out.println("showshow");
                //num = 55; //编译错误，匿名内部类中不能修改外面局部变量的值
                            //因为该变量在此处会默认为final的
            }
        };
        o3.show();
    }
 }
 interface InterInter{
    void show();
 }
 interface Inter{
 }

让我们再一起看看具体的实践

        List<String> list1 = new ArrayList<>();
        list1.add("你好啊");
        list1.add("哇你好( •̀ ω •́ )");
        list1.add("你好");
        Collections.sort(list1, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        System.out.println(list1);

那么是不是感觉还是就算简化了类的创建还是很麻烦，不够清晰明了，这就可以介绍今天的主角了Lambda表达式了

Lambda表达式

Lambda表达式是Java 8及更高版本中引入的一个特性，它提供了一种简洁的方式来表示匿名方法。Lambda表达式允许你以更直观、更简洁的方式编写代码，特别是在处理集合、事件监听或任何需要传递函数作为参数的场景中。

语法规则

Lambda表达式的基本语法由三部分组成：参数列表、箭头（->）和Lambda体（即方法体）。

(参数列表)->{
方法体
}

代码实例

在了解基本语法后我们来看看具体的实现接下来是匿名内部类写法和lambda表达式写法的对比

        //自定义比较器的匿名内部类写法
        Comparator<String> c1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        };

        //使用lambda表达式
        //lambda表达式就是省去了匿名内部类创建是接口与方法名部分
        Comparator<String> c2 = (String o1, String o2) -> {
            return o2.length() - o1.length();
        };

是不是简洁了许多，但是别急还能更加的简洁

        //lambda表达式可以忽略参数的类型
        //如果方法中只有一句代码时，该方法体的“{}”可以忽略不写
        //如果这句代码含有return关键字时，也要一起忽略return
        Comparator<String> c3 = (String o1, String o2) -> o2.length() - o1.length();

接下来再介绍一个基于lambda表达式遍历集合元素

forEach

JDK8之后，java在集合Collection接口中添加了一个用于遍历集合元素的forEach

        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        for (String e : c) {
            System.out.println(e);
        }
        //tips:当lambda中只有一个参数时，参数列表的"()"可以忽略不写
        c.forEach(e->System.out.println(e));
        /*
            JDK8中出现的lambda表达式的变种写法:方法引用
            对象::方法
            当lambda表达式的参数与方法体中调用方法的参数一致时
            例如:
            (e)->System.out.println(e);
            那么就可以写作:
            System.out::println;
                  对象::方法
            现在以了解为主即可
         */
        c.forEach(System.out::println);