如何打印Java函数式接口实例的代码表示？

这个问题挺有意思的——Java里的Lambda表达式本质是通过invokedynamic指令动态生成的字节码类，默认的toString()继承自Object，只会输出类似Main$1@6d06d69c的类名+哈希值，JVM本身并没有把Lambda的源码字符串存在运行时实例里。不过我们可以通过以下几种方式来实现需求：

1. 编译期手动保留源码信息 #

最简单的方式是用自定义注解，把Lambda的代码字符串手动存在注解中，运行时读取注解内容即可。这种方式需要你在定义Lambda时额外维护注解内容，适合对代码可控的场景：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;

// 定义运行时保留的注解
@Retention(RetentionPolicy.RUNTIME)
@Target(FIELD)
@interface LambdaSource {
    String value();
}

public class Main {
    public interface Function {
        double function(double input);
    }

    // 用注解标记Lambda的源码
    @LambdaSource("(x) -> x")
    private static Function f = (x) -> x;

    public static void main(String[] args) throws NoSuchFieldException {
        // 读取字段上的注解内容
        LambdaSource annotation = Main.class.getDeclaredField("f").getAnnotation(LambdaSource.class);
        if (annotation != null) {
            System.out.println("Lambda源码：" + annotation.value());
        }
    }
}

运行这段代码会输出：Lambda源码：(x) -> x，完全符合你的需求。

2. 运行时字节码反编译 #

如果不想手动维护注解，可以借助字节码分析工具（比如ASM、JD-Core、Procyon）在运行时反编译Lambda生成的类，提取出对应的实现代码。这种方式更自动化，但需要引入第三方库，实现也更复杂。

举个用JD-Core反编译的例子（需要先引入JD-Core的依赖）：

import org.jd.core.v1.ClassFileToJavaSourceDecompiler;
import org.jd.core.v1.api.loader.Loader;
import org.jd.core.v1.api.loader.LoaderException;
import org.jd.core.v1.api.printer.Printer;

import java.io.StringWriter;
import java.io.Writer;

public class LambdaDecompiler {
    public static String decompileLambda(Object lambdaInstance) throws LoaderException {
        Class<?> lambdaClass = lambdaInstance.getClass();
        ClassFileToJavaSourceDecompiler decompiler = new ClassFileToJavaSourceDecompiler();
        
        // 实现JD-Core的Loader接口，读取Lambda类的字节码
        Loader loader = internalName -> {
            try (var inputStream = lambdaClass.getClassLoader().getResourceAsStream(internalName + ".class")) {
                if (inputStream == null) return null;
                return inputStream.readAllBytes();
            } catch (Exception e) {
                throw new LoaderException(e);
            }
        };
        
        // 实现Printer接口，接收反编译后的代码
        Writer writer = new StringWriter();
        Printer printer = new Printer() {
            @Override
            public void print(String s) { writer.write(s); }
            @Override
            public void println(String s) { writer.write(s + System.lineSeparator()); }
            @Override
            public void printError(String s) {}
            @Override
            public void start(int i) {}
            @Override
            public void end() {}
            @Override
            public void indent() {}
            @Override
            public void unindent() {}
            @Override
            public void startLine(int i) {}
            @Override
            public void endLine() {}
            @Override
            public void extraLine(int i) {}
            @Override
            public void startMarker(int i) {}
            @Override
            public void endMarker(int i) {}
        };
        
        // 执行反编译
        decompiler.decompile(loader, printer, lambdaClass.getName());
        return writer.toString();
    }

    public static void main(String[] args) throws LoaderException {
        Function f = (x) -> x;
        String decompiledCode = decompileLambda(f);
        System.out.println("反编译后的Lambda代码：");
        System.out.println(decompiledCode);
    }

    public interface Function {
        double function(double input);
    }
}

运行后会输出类似这样的反编译结果：

public final class Main$$Lambda$1 implements Main.Function {
    public double function(double var1) {
        return var1;
    }
}

你可以从反编译结果中提取出核心的实现逻辑，转换成你想要的(x) -> x或者double function(double x) { return x; }格式。

为什么直接toString()不行？ #

Lambda表达式在Java中是通过动态生成的匿名内部类实现的，但这个类是在运行时由JVM通过invokedynamic生成的，并没有保留源码字符串。默认的toString()方法继承自Object，所以只会输出类的全限定名加上哈希值，这是正常现象。

内容的提问来源于stack exchange，提问作者MazeOfEncryption