前言

java 反编译，一听可能觉得高深莫测，其实反编译并不是什么特别高级的操作，java 对于 class 字节码文件的生成有着严格的要求，如果你非常熟悉 java 虚拟机规范，了解 class 字节码文件中一些字节的作用，那么理解反编译的原理并不是什么问题。甚至像下面这样的 class 文件你都能看懂一二。

一般在逆向研究和代码分析中，反编译用到的比较多。不过在日常开发中，有时候只是简单的看一下所用依赖类的反编译，也是十分重要的。

恰好最近工作中也需要用到 java 反编译，所以这篇文章介绍目前常见的的几种 java 反编译工具的使用，在文章的最后也会通过编译速度、语法支持以及代码可读性三个维度，对它们进行测试，分析几款工具的优缺点。

procyon

github 链接：https://github.com/mstrobel/procyon

procyon 不仅仅是反编译工具，它其实是专注于 java 代码的生成和分析的一整套的 java 元编程工具。主要包括下面几个部分：

• core framework
• reflection framework
• expressions framework
• compiler toolset (experimental)
• java decompiler (experimental)

可以看到反编译只是 procyon 的其中一个模块，procyon 原来托管于 bitbucket，后来迁移到了 github，根据 github 的提交记录来看，也有将近两年没有更新了。不过也有依赖 procyon 的其他的开源反编译工具如** decompiler-procyon**，更新频率还是很高的，下面也会选择这个工具进行反编译测试。

使用 procyon

<!-- https://mvnrepository.com/artifact/org.jboss.windup.decompiler/decompiler-procyon -->
<dependency>
    <groupid>org.jboss.windup.decompiler</groupid>
    <artifactid>decompiler-procyon</artifactid>
    <version>5.1.4.final</version>
</dependency>

写一个简单的反编译测试。

package com.wdbyte.decompiler;

import java.io.ioexception;
import java.nio.file.path;
import java.nio.file.paths;
import java.util.iterator;
import java.util.list;

import org.jboss.windup.decompiler.api.decompilationfailure;
import org.jboss.windup.decompiler.api.decompilationlistener;
import org.jboss.windup.decompiler.api.decompilationresult;
import org.jboss.windup.decompiler.api.decompiler;
import org.jboss.windup.decompiler.procyon.procyondecompiler;

/**
 * procyon 反编译测试
 *
 *  @author https://github.com/niumoo
 * @date 2021/05/15
 */
public class procyontest {
    public static void main(string[] args) throws ioexception {
        long time = procyon("decompiler.jar", "procyon_output_jar");
        system.out.println(string.format("decompiler time: %dms", time));
    }
    public static long procyon(string source,string targetpath) throws ioexception {
        long start = system.currenttimemillis();
        path outdir = paths.get(targetpath);
        path archive = paths.get(source);
        decompiler dec = new procyondecompiler();
        decompilationresult res = dec.decompilearchive(archive, outdir, new decompilationlistener() {
            public void decompilationprocesscomplete() {
                system.out.println("decompilationprocesscomplete");
            }
            public void decompilationfailed(list<string> inputpath, string message) {
                system.out.println("decompilationfailed");
            }
            public void filedecompiled(list<string> inputpath, string outputpath) {
            }
            public boolean iscancelled() {
                return false;
            }
        });

        if (!res.getfailures().isempty()) {
            stringbuilder sb = new stringbuilder();
            sb.append("failed decompilation of " + res.getfailures().size() + " classes: ");
            iterator failureiterator = res.getfailures().iterator();
            while (failureiterator.hasnext()) {
                decompilationfailure dex = (decompilationfailure)failureiterator.next();
                sb.append(system.lineseparator() + "    ").append(dex.getmessage());
            }
            system.out.println(sb.tostring());
        }
        system.out.println("compilation results: " + res.getdecompiledfiles().size() + " succeeded, " + res.getfailures().size() + " failed.");
        dec.close();
        long end = system.currenttimemillis();
        return end - start;
    }
}

procyon 在反编译时会实时输出反编译文件数量的进度情况，最后还会统计反编译成功和失败的 class 文件数量。

....
五月 15, 2021 10:58:28 下午 org.jboss.windup.decompiler.procyon.procyondecompiler$3 call
信息: decompiling 650 / 783
五月 15, 2021 10:58:30 下午 org.jboss.windup.decompiler.procyon.procyondecompiler$3 call
信息: decompiling 700 / 783
五月 15, 2021 10:58:37 下午 org.jboss.windup.decompiler.procyon.procyondecompiler$3 call
信息: decompiling 750 / 783
decompilationprocesscomplete
compilation results: 783 succeeded, 0 failed.
decompiler time: 40599ms

procyon gui

对于 procyon 反编译来说，在 github 上也有基于此实现的开源 gui 界面，感兴趣的可以下载尝试。
github 地址：https://github.com/deathmarine/luyten

cfr

github 地址：https://github.com/leibnitz27/cfr
cfr 官方网站：http://www.benf.org/other/cfr/（可能需要fq）
maven 仓库：https://mvnrepository.com/artifact/org.benf/cfr

cfr（class file reader） 可以支持 java 9、java 12、java 14 以及其他的最新版 java 代码的反编译工作。而且 cfr 本身的代码是由 java 6 编写，所以基本可以使用 cfr 在任何版本的 java 程序中。值得一提的是，使用 cfr 甚至可以将使用其他语言编写的的 jvm 类文件反编译回 java 文件。

cfr 命令行使用

使用 cfr 反编译时，你可以下载已经发布的 jar 包，进行命令行反编译，也可以使用 maven 引入的方式，在代码中使用。下面先说命令行运行的方式。

直接在 github tags 下载已发布的最新版 jar. 可以直接运行查看帮助。

# 查看帮助
java -jar cfr-0.151.jar --help

如果只是反编译某个 class.

# 反编译 class 文件，结果输出到控制台
java -jar cfr-0.151.jar windupclasspathtypeloader.class
# 反编译 class 文件，结果输出到 out 文件夹
java -jar cfr-0.151.jar windupclasspathtypeloader.class --outputpath ./out

反编译某个 jar.

# 反编译 jar 文件，结果输出到 output_jar 文件夹
➜  desktop java -jar cfr-0.151.jar decompiler.jar --outputdir ./output_jar
processing decompiler.jar (use silent to silence)
processing com.strobel.assembler.metadata.arraytypeloader
processing com.strobel.assembler.metadata.parameterdefinition
processing com.strobel.assembler.metadata.methodhandle
processing com.strobel.assembler.metadata.signatures.floatsignature
.....

反编译结果会按照 class 的包路径写入到指定文件夹中。

cfr 代码中使用

添加依赖这里不提。

<!-- https://mvnrepository.com/artifact/org.benf/cfr -->
<dependency>
    <groupid>org.benf</groupid>
    <artifactid>cfr</artifactid>
    <version>0.151</version>
</dependency>

实际上我在官方网站和 github 上都没有看到具体的单元测试示例。不过没有关系，既然能在命令行运行，那么直接在 idea 中查看反编译后的 main 方法入口，看下命令行是怎么执行的，就可以写出自己的单元测试了。

package com.wdbyte.decompiler;

import java.io.ioexception;
import java.util.arraylist;
import java.util.hashmap;
import java.util.list;

import org.benf.cfr.reader.api.cfrdriver;
import org.benf.cfr.reader.util.getopt.optionsimpl;

/**
 * cfr test
 *
 * @author https://github.com/niumoo
 * @date 2021/05/15
 */
public class cfrtest {
    public static void main(string[] args) throws ioexception {
        long time = cfr("decompiler.jar", "./cfr_output_jar");
        system.out.println(string.format("decompiler time: %dms", time));
        // decompiler time: 11655ms
    }
    public static long cfr(string source, string targetpath) throws ioexception {
        long start = system.currenttimemillis();
        // source jar
        list<string> files = new arraylist<>();
        files.add(source);
        // target dir
        hashmap<string, string> outputmap = new hashmap<>();
        outputmap.put("outputdir", targetpath);

        optionsimpl options = new optionsimpl(outputmap);
        cfrdriver cfrdriver = new cfrdriver.builder().withbuiltoptions(options).build();
        cfrdriver.analyse(files);
        long end = system.currenttimemillis();
        return (end - start);
    }
}

jd-core

gihub 地址：https://github.com/java-decompiler/jd-core
jd-core 官方网址：https://java-decompiler.github.io/
jd-core 是一个的独立的 java 库，可以用于 java 的反编译，支持从 java 1 至 java 12 的字节码反编译，包括 lambda 表达式、方式引用、默认方法等。知名的 jd-gui 和 eclipse 无缝集成反编译引擎就是 jd-core。jd-core 提供了一些反编译的核心功能，也提供了单独的 class 反编译方法，但是如果你想在自己的代码中去直接反编译整个 jar 包，还是需要一些改造的，如果是代码中有匿名函数，lambda 等，虽然可以直接反编译，不过也需要额外考虑。

使用 jd-core

        <!-- https://mvnrepository.com/artifact/org.jd/jd-core -->
        <dependency>
            <groupid>org.jd</groupid>
            <artifactid>jd-core</artifactid>
            <version>1.1.3</version>
        </dependency>

为了可以反编译整个 jar 包，使用的代码我做了一些简单改造，以便于最后一部分的对比测试，但是这个示例中没有考虑内部类，lambda 等会编译出多个 class 文件的情况，所以不能直接使用在生产中。

package com.wdbyte.decompiler;

import java.io.file;
import java.io.ioexception;
import java.io.inputstream;
import java.nio.file.files;
import java.nio.file.path;
import java.nio.file.paths;
import java.util.enumeration;
import java.util.hashmap;
import java.util.jar.jarfile;
import java.util.zip.zipentry;
import java.util.zip.zipfile;

import org.apache.commons.io.ioutils;
import org.apache.commons.lang3.stringutils;
import org.jd.core.v1.classfiletojavasourcedecompiler;
import org.jd.core.v1.api.loader.loader;
import org.jd.core.v1.api.printer.printer;

/**
 * @author https://github.com/niumoo
 * @date 2021/05/15
 */
public class jdcoretest {

    public static void main(string[] args) throws exception {
        jdcoredecompiler jdcoredecompiler = new jdcoredecompiler();
        long time = jdcoredecompiler.decompiler("decompiler.jar","jd_output_jar");
        system.out.println(string.format("decompiler time: %dms", time));
    }
}


class jdcoredecompiler{

    private classfiletojavasourcedecompiler decompiler = new classfiletojavasourcedecompiler();
    // 存放字节码
    private hashmap<string,byte[]> classbytemap = new hashmap<>();

    /**
     * 注意：没有考虑一个 java 类编译出多个 class 文件的情况。
     * 
     * @param source
     * @param target
     * @return
     * @throws exception
     */
    public long decompiler(string source,string target) throws exception {
        long start = system.currenttimemillis();
        // 解压
        archive(source);
        for (string classname : classbytemap.keyset()) {
            string path = stringutils.substringbeforelast(classname, "/");
            string name = stringutils.substringafterlast(classname, "/");
            if (stringutils.contains(name, "$")) {
                name = stringutils.substringafterlast(name, "$");
            }
            name = stringutils.replace(name, ".class", ".java");
            decompiler.decompile(loader, printer, classname);
            string context = printer.tostring();
            path targetpath = paths.get(target + "/" + path + "/" + name);
            if (!files.exists(paths.get(target + "/" + path))) {
                files.createdirectories(paths.get(target + "/" + path));
            }
            files.deleteifexists(targetpath);
            files.createfile(targetpath);
            files.write(targetpath, context.getbytes());
        }
        return system.currenttimemillis() - start;
    }
    private void archive(string path) throws ioexception {
        try (zipfile archive = new jarfile(new file(path))) {
            enumeration<? extends zipentry> entries = archive.entries();
            while (entries.hasmoreelements()) {
                zipentry entry = entries.nextelement();
                if (!entry.isdirectory()) {
                    string name = entry.getname();
                    if (name.endswith(".class")) {
                        byte[] bytes = null;
                        try (inputstream stream = archive.getinputstream(entry)) {
                            bytes = ioutils.tobytearray(stream);
                        }
                        classbytemap.put(name, bytes);
                    }
                }
            }
        }
    }

    private loader loader = new loader() {
        @override
        public byte[] load(string internalname) {
            return classbytemap.get(internalname);
        }
        @override
        public boolean canload(string internalname) {
            return classbytemap.containskey(internalname);
        }
    };

    private printer printer = new printer() {
        protected static final string tab = "  ";
        protected static final string newline = "n";
        protected int indentationcount = 0;
        protected stringbuilder sb = new stringbuilder();
        @override public string tostring() {
            string tostring = sb.tostring();
            sb = new stringbuilder();
            return tostring;
        }
        @override public void start(int maxlinenumber, int majorversion, int minorversion) {}
        @override public void end() {}
        @override public void printtext(string text) { sb.append(text); }
        @override public void printnumericconstant(string constant) { sb.append(constant); }
        @override public void printstringconstant(string constant, string ownerinternalname) { sb.append(constant); }
        @override public void printkeyword(string keyword) { sb.append(keyword); }
        @override public void printdeclaration(int type, string internaltypename, string name, string descriptor) { sb.append(name); }
        @override public void printreference(int type, string internaltypename, string name, string descriptor, string ownerinternalname) { sb.append(name); }
        @override public void indent() { this.indentationcount++; }
        @override public void unindent() { this.indentationcount--; }
        @override public void startline(int linenumber) { for (int i=0; i<indentationcount; i++) sb.append(tab); }
        @override public void endline() { sb.append(newline); }
        @override public void extraline(int count) { while (count-- > 0) sb.append(newline); }
        @override public void startmarker(int type) {}
        @override public void endmarker(int type) {}
    };
}

jd-gui

github 地址：https://github.com/java-decompiler/jd-gui
jd-core 也提供了官方的 gui 界面，需要的也可以直接下载尝试。

jadx

github 地址：https://github.com/skylot/jadx
jadx 是一款可以反编译 jar、apk、dex、aar、aab、zip 文件的反编译工具，并且也配有 jadx-gui 用于界面操作。jadx 使用 grade 进行依赖管理，可以自行克隆仓库打包运行。

git clone https://github.com/skylot/jadx.git
cd jadx
./gradlew dist
# 查看帮助
 ./build/jadx/bin/jadx --help
 
jadx - dex to java decompiler, version: dev

usage: jadx [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab)
options:
  -d, --output-dir                    - output directory
  -ds, --output-dir-src               - output directory for sources
  -dr, --output-dir-res               - output directory for resources
  -r, --no-res                        - do not decode resources
  -s, --no-src                        - do not decompile source code
  --single-class                      - decompile a single class
  --output-format                     - can be 'java' or 'json', default: java
  -e, --export-gradle                 - save as android gradle project
  -j, --threads-count                 - processing threads count, default: 6
  --show-bad-code                     - show inconsistent code (incorrectly decompiled)
  --no-imports                        - disable use of imports, always write entire package name
  --no-debug-info                     - disable debug info
  --add-debug-lines                   - add comments with debug line numbers if available
  --no-inline-anonymous               - disable anonymous classes inline
  --no-replace-consts                 - don't replace constant value with matching constant field
  --escape-unicode                    - escape non latin characters in strings (with u)
  --respect-bytecode-access-modifiers - don't change original access modifiers
  --deobf                             - activate deobfuscation
  --deobf-min                         - min length of name, renamed if shorter, default: 3
  --deobf-max                         - max length of name, renamed if longer, default: 64
  --deobf-cfg-file                    - deobfuscation map file, default: same dir and name as input file with '.jobf' extension
  --deobf-rewrite-cfg                 - force to save deobfuscation map
  --deobf-use-sourcename              - use source file name as class name alias
  --deobf-parse-kotlin-metadata       - parse kotlin metadata to class and package names
  --rename-flags                      - what to rename, comma-separated, 'case' for system case sensitivity, 'valid' for java identifiers, 'printable' characters, 'none' or 'all' (default)
  --fs-case-sensitive                 - treat filesystem as case sensitive, false by default
  --cfg                               - save methods control flow graph to dot file
  --raw-cfg                           - save methods control flow graph (use raw instructions)
  -f, --fallback                      - make simple dump (using goto instead of 'if', 'for', etc)
  -v, --verbose                       - verbose output (set --log-level to debug)
  -q, --quiet                         - turn off output (set --log-level to quiet)
  --log-level                         - set log level, values: quiet, progress, error, warn, info, debug, default: progress
  --version                           - print jadx version
  -h, --help                          - print this help
example:
  jadx -d out classes.dex

根据 help 信息，如果想要反编译 decompiler.jar 到 out 文件夹。

./build/jadx/bin/jadx -d ./out ~/desktop/decompiler.jar 
info  - loading ...
info  - processing ...
info  - doneress: 1143 of 1217 (93%)

fernflower

github 地址：https://github.com/fesh0r/fernflower
fernflower 和 jadx 一样使用 grade 进行依赖管理，可以自行克隆仓库打包运行。

➜  fernflower-master ./gradlew build

build successful in 32s
4 actionable tasks: 4 executed

➜  fernflower-master java -jar build/libs/fernflower.jar
usage: java -jar fernflower.jar [-<option>=<value>]* [<source>]+ <destination>
example: java -jar fernflower.jar -dgs=true c:mysource c:my.jar d:decompiled

➜  fernflower-master mkdir out
➜  fernflower-master java -jar build/libs/fernflower.jar ~/desktop/decompiler.jar ./out
info:  decompiling class com/strobel/assembler/metadata/arraytypeloader
info:  ... done
info:  decompiling class com/strobel/assembler/metadata/parameterdefinition
info:  ... done
info:  decompiling class com/strobel/assembler/metadata/methodhandle
...

➜  fernflower-master ll out
total 1288
-rw-r--r--  1 darcy  staff   595k  5 16 17:47 decompiler.jar
➜  fernflower-master

fernflower 在反编译 jar 同时，默认反编译的结果也是一个 jar 包。jad

反编译速度

到这里已经介绍了五款 java 反编译工具了，那么在日常开发中我们应该使用哪一个呢？又或者在代码分析时我们又该选择哪一个呢？我想这两种情况的不同，使用时的关注点也是不同的。如果是日常使用，读读代码，我想应该是对可读性要求更高些，如果是大量的代码分析工作，那么可能反编译的速度和语法的支持上要求更高些。为了能有一个简单的参考数据，我使用 jmh 微基准测试工具分别对这五款反编译工具进行了简单的测试，下面是一些测试结果。

测试环境

环境变量描述处理器2.6 ghz 六核intel core i7内存16 gb 2667 mhz ddr4java 版本jdk 14.0.2测试方式jmh 基准测试。待反编译 jar 1procyon-compilertools-0.5.33.jar (1.5 mb)待反编译 jar 2python2java4common-1.0.0-20180706.084921-1.jar (42 mb)

反编译 jar 1：procyon-compilertools-0.5.33.jar (1.5 mb)

benchmarkmodecntscoreunitscfravgt106548.642 ± 363.502ms/opfernfloweravgt1012699.147 ± 1081.539ms/opjdcoreavgt105728.621 ± 310.645ms/opprocyonavgt1026776.125 ± 2651.081ms/opjadxavgt107059.354 ± 323.351ms/op

反编译 jar 2: python2java4common-1.0.0-20180706.084921-1.jar (42 mb)

jar 2 这个包是比较大的，是拿很多代码仓库合并到一起的，同时还有很多 python 转 java 生成的代码，理论上代码的复杂度会更高。

benchmarkcntscorecfr1413838.826msfernflower1246819.168msjdcore1errorprocyon1487647.181msjadx1505600.231ms

语法支持和可读性

如果反编译后的代码需要自己看的话，那么可读性更好的代码更占优势，下面我写了一些代码，主要是 java 8 及以下的代码语法和一些嵌套的流程控制，看看反编译后的效果如何。

package com.wdbyte.decompiler;

import java.util.arraylist;
import java.util.list;
import java.util.stream.intstream;

import org.benf.cfr.reader.util.functors.unaryfunction;

/**
 * @author https://www.wdbyte.com
 * @date 2021/05/16
 */
public class hardcode <a, b> {
    public hardcode(a a, b b) { }

    public static void test(int... args) { }

    public static void main(string... args) {
        test(1, 2, 3, 4, 5, 6);
    }

    int byteand0() {
        int b = 1;
        int x = 0;
        do {
            b = (byte)((b ^ x));
        } while (b++ < 10);
        return b;
    }

    private void a(integer i) {
        a(i);
        b(i);
        c(i);
    }

    private void b(int i) {
        a(i);
        b(i);
        c(i);
    }

    private void c(double d) {
        c(d);
        d(d);
    }

    private void d(double d) {
        c(d);
        d(d);
    }

    private void e(short s) {
        b(s);
        c(s);
        e(s);
        f(s);
    }

    private void f(short s) {
        b(s);
        c(s);
        e(s);
        f(s);
    }

    void test1(string path) {
        try {
            int x = 3;
        } catch (nullpointerexception t) {
            system.out.println("file not found");
            if (path == null) { return; }
            throw t;
        } finally {
            system.out.println("fred");
            if (path == null) { throw new illegalstateexception(); }
        }
    }

    private final list<integer> stuff = new arraylist<>();{
        stuff.add(1);
        stuff.add(2);
    }

    public static int plus(boolean t, int a, int b) {
        int c = t ? a : b;
        return c;
    }

    // lambda
    integer lambdainvoker(int arg, unaryfunction<integer, integer> fn) {
        return fn.invoke(arg);
    }

    // lambda
    public int testlambda() {
        return lambdainvoker(3, x -> x + 1);
        //        return 1;
    }

    // lambda
    public integer testlambda(list<integer> stuff, int y, boolean b) {
        return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findfirst().orelse(null);
    }

    // stream
    public static <y extends integer> void teststream(list<y> list) {
        intstream s = list.stream()
            .filter(x -> {
                system.out.println(x);
                return x.intvalue() / 2 == 0;
                })
            .map(x -> (integer)x+2)
            .maptoint(x -> x);
        s.toarray();
    }

    // switch
    public void testswitch1(){
        int i = 0;
        switch(((long)(i + 1l)) + "") {
            case "1":
                system.out.println("one");
        }
    }
    // switch
    public void testswitch2(string string){
        switch (string) {
            case "apples":
                system.out.println("apples");
                break;
            case "pears":
                system.out.println("pears");
                break;
        }
    }

    // switch
    public static void testswitch3(int x) {
        while (true) {
            if (x < 5) {
                switch ("test") {
                    case "okay":
                        continue;
                    default:
                        continue;
                }
            }
            system.out.println("wow x2!");
        }
    }
}

此处本来贴出了所有工具的反编译结果，但是碍于文章长度和阅读体验，没有放出来，不过我在个人博客的发布上是有完整代码的，个人网站排版比较自由，可以使用 tab 选项卡的方式展示。如果需要查看可以访问 https://www.wdbyte.com 进行查看。

procyon

看到 procyon 的反编译结果，还是比较吃惊的，在正常反编译的情况下，反编译后的代码基本上都是原汁原味。唯一一处反编译后和源码语法上有变化的地方，是一个集合的初始化操作略有不同。

// 源码
 public hardcode(a a, b b) { }
 private final list<integer> stuff = new arraylist<>();{
    stuff.add(1);
    stuff.add(2);
 }
// procyon 反编译
private final list<integer> stuff;
    
public hardcode(final a a, final b b) {
    (this.stuff = new arraylist<integer>()).add(1);
    this.stuff.add(2);
}

而其他部分代码， 比如装箱拆箱，switch 语法，lambda 表达式，流式操作以及流程控制等，几乎完全一致，阅读没有障碍。

装箱拆箱操作反编译后完全一致，没有多余的类型转换代码。

// 源码
private void a(integer i) {
    a(i);
    b(i);
    c(i);
}

private void b(int i) {
    a(i);
    b(i);
    c(i);
}

private void c(double d) {
    c(d);
    d(d);
}

private void d(double d) {
    c(d);
    d(d);
}

private void e(short s) {
    b(s);
    c(s);
    e(s);
    f(s);
}

private void f(short s) {
    b(s);
    c(s);
    e(s);
    f(s);
}
// procyon 反编译
private void a(final integer i) {
    this.a(i);
    this.b(i);
    this.c(i);
}

private void b(final int i) {
    this.a(i);
    this.b(i);
    this.c(i);
}

private void c(final double d) {
    this.c(d);
    this.d(d);
}

private void d(final double d) {
    this.c(d);
    this.d(d);
}

private void e(final short s) {
    this.b(s);
    this.c(s);
    this.e(s);
    this.f(s);
}

private void f(final short s) {
    this.b(s);
    this.c(s);
    this.e(s);
    this.f(s);
}

switch 部分也是一致，流程控制部分也没有变化。

// 源码 switch
public void testswitch1(){
    int i = 0;
    switch(((long)(i + 1l)) + "") {
        case "1":
            system.out.println("one");
    }
}
public void testswitch2(string string){
    switch (string) {
        case "apples":
            system.out.println("apples");
            break;
        case "pears":
            system.out.println("pears");
            break;
    }
}
public static void testswitch3(int x) {
    while (true) {
        if (x < 5) {
            switch ("test") {
                case "okay":
                    continue;
                default:
                    continue;
            }
        }
        system.out.println("wow x2!");
    }
}
// procyon 反编译
public void testswitch1() {
    final int i = 0;
    final string string = (object)(i + 1l) + "";
    switch (string) {
        case "1": {
            system.out.println("one");
            break;
        }
    }
}
public void testswitch2(final string string) {
    switch (string) {
        case "apples": {
            system.out.println("apples");
            break;
        }
        case "pears": {
            system.out.println("pears");
            break;
        }
    }
}   
public static void testswitch3(final int x) {
    while (true) {
        if (x < 5) {
            final string s = "test";
            switch (s) {
                case "okay": {
                    continue;
                }
                default: {
                    continue;
                }
            }
        }
        else {
            system.out.println("wow x2!");
        }
    }
}

lambda 表达式和流式操作完全一致。

// 源码
// lambda
public integer testlambda(list<integer> stuff, int y, boolean b) {
    return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findfirst().orelse(null);
}

// stream
public static <y extends integer> void teststream(list<y> list) {
    intstream s = list.stream()
        .filter(x -> {
            system.out.println(x);
            return x.intvalue() / 2 == 0;
            })
        .map(x -> (integer)x+2)
        .maptoint(x -> x);
    s.toarray();
}
// procyon 反编译
public integer testlambda(final list<integer> stuff, final int y, final boolean b) {
    return stuff.stream().filter(b ? (x -> x > y) : (x -> x < 3)).findfirst().orelse(null);
}

public static <y extends integer> void teststream(final list<y> list) {
    final intstream s = list.stream().filter(x -> {
        system.out.println(x);
        return x / 2 == 0;
    }).map(x -> x + 2).maptoint(x -> x);
    s.toarray();
}

流程控制，反编译后发现丢失了无异议的代码部分，阅读来说并无障碍。

// 源码
void test1(string path) {
    try {
        int x = 3;
    } catch (nullpointerexception t) {
        system.out.println("file not found");
        if (path == null) { return; }
        throw t;
    } finally {
        system.out.println("fred");
        if (path == null) { throw new illegalstateexception(); }
    }
}
// procyon 反编译
void test1(final string path) {
    try {}
    catch (nullpointerexception t) {
        system.out.println("file not found");
        if (path == null) {
            return;
        }
        throw t;
    }
    finally {
        system.out.println("fred");
        if (path == null) {
            throw new illegalstateexception();
        }
    }
}

鉴于代码篇幅，下面几种的反编译结果的对比只会列出不同之处，相同之处会直接跳过。

cfr

cfr 的反编译结果多出了类型转换部分，个人来看没有 procyon 那么原汁原味，不过也算是十分优秀，测试案例中唯一不满意的地方是对 while continue 的处理。

// cfr 反编译结果
// 装箱拆箱
private void e(short s) {
   this.b(s.shortvalue()); // 装箱拆箱多出了类型转换部分。
   this.c(s.shortvalue()); // 装箱拆箱多出了类型转换部分。
   this.e(s);
   this.f(s);
}
// 流程控制
void test1(string path) {
    try {
        int n = 3;// 流程控制反编译结果十分满意，原汁原味，甚至此处的无意思代码都保留了。
    }
    catch (nullpointerexception t) {
        system.out.println("file not found");
        if (path == null) {
            return;
        }
        throw t;
    }
    finally {
        system.out.println("fred");
        if (path == null) {
            throw new illegalstateexception();
        }
    }
}
// lambda 和 stream 操作完全一致，不提。
// switch 处，反编译后功能一致，但是流程控制有所更改。
public static void testswitch3(int x) {
    block6: while (true) { // 源码中只有 while(true)，反编译后多了 block6
        if (x < 5) {
            switch ("test") {
                case "okay": {
                    continue block6; // 多了 block6
                }
            }
            continue;
        }
        system.out.println("wow x2!");
    }
}

jd-core

jd-core 和 cfr 一样，对于装箱拆箱操作，反编译后不再一致，多了类型转换部分，而且自动优化了数据类型。个人感觉，如果是反编译后自己阅读，通篇的数据类型的转换优化影响还是挺大的。

// jd-core 反编译
private void d(double d) {
  c(d.doublevalue()); // 新增了数据类型转换
  d(d);
}

private void e(short s) {
  b(s.shortvalue()); // 新增了数据类型转换
  c(s.shortvalue()); // 新增了数据类型转换
  e(s);
  f(s.shortvalue()); // 新增了数据类型转换
}

private void f(short s) {
  b(s);
  c(s);
  e(short.valueof(s)); // 新增了数据类型转换
  f(s);
}
// stream 操作中，也自动优化了数据类型转换，阅读起来比较累。
public static <y extends integer> void teststream(list<y> list) {
  intstream s = list.stream().filter(x -> {
        system.out.println(x);
        return (x.intvalue() / 2 == 0);
      }).map(x -> integer.valueof(x.intvalue() + 2)).maptoint(x -> x.intvalue());
  s.toarray();
}

jadx

首先 jadx 在反编译测试代码时，报出了错误，反编译的结果里也有提示不能反编 lambda 和 stream 操作，反编译结果中变量名称杂乱无章，流程控制几乎阵亡，如果你想反编译后生物肉眼阅读，jadx 肯定不是一个好选择。

// jadx 反编译
private void e(short s) {
    b(s.shortvalue());// 新增了数据类型转换
    c((double) s.shortvalue());// 新增了数据类型转换
    e(s);
    f(s.shortvalue());// 新增了数据类型转换
}

private void f(short s) {
    b(s);
    c((double) s);// 新增了数据类型转换
    e(short.valueof(s));// 新增了数据类型转换
    f(s);
}
public int testlambda() { // testlambda 反编译失败
    /*
        r2 = this;
        r0 = 3
        r1 = move-result
        java.lang.integer r0 = r2.lambdainvoker(r0, r1)
        int r0 = r0.intvalue()
        return r0
    */
    throw new unsupportedoperationexception("method not decompiled: com.wdbyte.decompiler.hardcode.testlambda():int");
}
// stream 反编译失败
public static <y extends java.lang.integer> void teststream(java.util.list<y> r3) {
    /*
        java.util.stream.stream r1 = r3.stream()
        r2 = move-result
        java.util.stream.stream r1 = r1.filter(r2)
        r2 = move-result
        java.util.stream.stream r1 = r1.map(r2)
        r2 = move-result
        java.util.stream.intstream r0 = r1.maptoint(r2)
        r0.toarray()
        return
    */
    throw new unsupportedoperationexception("method not decompiled: com.wdbyte.decompiler.hardcode.teststream(java.util.list):void");
}
public void testswitch2(string string) { // switch 操作无法正常阅读，和源码出入较大。
    char c = 65535;
    switch (string.hashcode()) {
        case -1411061671:
            if (string.equals("apples")) {
                c = 0;
                break;
            }
            break;
        case 106540109:
            if (string.equals("pears")) {
                c = 1;
                break;
            }
            break;
    }
    switch (c) {
        case 0:
            system.out.println("apples");
            return;
        case 1:
            system.out.println("pears");
            return;
        default:
            return;
    }
}

fernflower

fernflower 的反编译结果总体上还是不错的，不过也有不足，它对变量名称的指定，以及 switch 字符串时的反编译结果不够理想。

//反编译后变量命名不利于阅读，有很多 var 变量
int byteand0() {
   int b = 1;
   byte x = 0;

   byte var10000;
   do {
      int b = (byte)(b ^ x);
      var10000 = b;
      b = b + 1;
   } while(var10000 < 10);

   return b;
}
// switch 反编译结果使用了hashcode
public static void testswitch3(int x) {
   while(true) {
      if (x < 5) {
         string var1 = "test";
         byte var2 = -1;
         switch(var1.hashcode()) {
         case 3412756: 
            if (var1.equals("okay")) {
               var2 = 0;
           }
         default:
            switch(var2) {
            case 0:
            }
         }
      } else {
         system.out.println("wow x2!");
      }
   }
}

总结

五种反编译工具比较下来，结合反编译速度和代码可读性测试，看起来 cfr 工具胜出，procyon 紧随其后。cfr 在速度上不落下风，在反编译的代码可读性上，是最好的，主要体现在反编译后的变量命名、装箱拆箱、类型转换，流程控制上，以及对 lambda 表达式、stream 流式操作和 switch 的语法支持上，都非常优秀。根据 cfr 官方介绍，已经支持到 java 14 语法，而且截止写这篇测试文章时，cfr 最新提交代码时间是在 11 小时之前，更新速度很快。

文中部分代码已经上传 github 的 niumoo/lab-notes 仓库 的 java-decompiler 目录。