Java 需要帮助选择以下代码吗

我使用GoogleGuava库递归地从提到的包中获取所有类，并遍历所有公共方法并获取它们的参数。然后，“mapOfpackageMethodParameters”将传递给gson对象，该对象将为我提供json

是否有任何方法可以通过使用lambdas或java8流api来优化最内层的两个for循环。还有其他建议吗

String[] packagenames = { "com.example" };
LinkedHashMap<String, LinkedHashMap<String, LinkedHashMap<String, String>>> mapOfpackageMethodParameters = new LinkedHashMap<>();
for (String packagename : packagenames) {
    List<ClassInfo> clazzList = ClassPath.from(ClassLoader.getSystemClassLoader())
            .getTopLevelClassesRecursive(packagename).stream().filter(c -> c.getPackageName().endsWith("test"))
            .collect(Collectors.toList());
    for (ClassInfo class1 : clazzList) {
        List<Method> methodList = Arrays.asList(Class.forName(class1.getName()).getMethods());
        LinkedHashMap<String, LinkedHashMap<String, String>> methodMap = new LinkedHashMap<>();
        for (Method method : methodList) {
            List<Parameter> parameterList = Arrays.asList(method.getParameters());
            LinkedHashMap<String, String> parameterMap = parameterList.stream()
                    .collect(Collectors.toMap(param -> param.getName(), param -> param.getType().toString(),
                            (x, y) -> x, LinkedHashMap::new));
            methodMap.put(method.getName(), parameterMap);
        }
        mapOfpackageMethodParameters.put(class1.getName(), methodMap);
    }
}

---

您可以将每个

for..each

循环转换为一个流，该流收集到

LinkedHashMap

中。使整个操作非常实用

String[] packageNames = { "com.example" };
LinkedHashMap<String, LinkedHashMap<String, LinkedHashMap<String, String>>> mapOfpackageMethodParameters = Arrays
    .stream(packageNames)
    .flatMap(packageName -> ClassPath
        .from(ClassLoader.getSystemClassLoader())
        .getTopLevelClassesRecursive(packageName)
        .stream())
    .filter(classInfo -> classInfo.getPackageName().endsWith("test"))
    .map(ClassInfo::load)
    .collect(Collectors.toMap(
        Class::getName,
        clazz -> Arrays
            .stream(clazz.getMethods())
            .collect(Collectors.toMap(
                Method::getName,
                method -> Arrays
                    .stream(method.getParameters())
                    .collect(Collectors.toMap(
                        Parameter::getName,
                        param -> param.getType().toString(),
                        (x, y) -> x, LinkedHashMap::new)),
                (x, y) -> x, LinkedHashMap::new)),
        (x, y) -> x, LinkedHashMap::new));

String[]packageNames={“com.example”}；
LinkedHashMapofPackageMethodParameters=数组
.stream（packageNames）
.flatMap（packageName->ClassPath
.from（ClassLoader.getSystemClassLoader（））
.GetToLevel类安全性（packageName）
.stream（））
.filter（classInfo->classInfo.getPackageName（）.endsWith（“测试”））
.map（ClassInfo:：load）
.collect（collector.toMap）(
类：：getName，
clazz->数组
.stream（clazz.getMethods（））
.collect（collector.toMap）(
方法：：getName，
方法->数组
.stream（方法.getParameters（））
.collect（collector.toMap）(
参数：：getName，
param->param.getType（）.toString（），
（x，y）->x，LinkedHashMap:：new）），
（x，y）->x，LinkedHashMap:：new）），
（x，y）->x，LinkedHashMap:：new）；

您是想优化它的性能，还是从代码复杂性的角度进行优化？主要是优化复杂性。顺便说一下，使用parallelStream右写中介方法可以提高性能。你的代码很难辨认，因为你在一个地方放了太多东西。如果您计划将所有这些作为gson对象返回，我强烈建议您编写需要返回的特定对象，如

PackageJson

，

ClassJson

，

MethodJson

。然后，这些对象将由Gson自动转换。删除地图已经是降低复杂性的一大步，因为你的泛型较少，这使得整个东西难以辨认。@OlivierGrégoire感谢你的建议。但我已经试过了，代码花费了太多时间来生成具有相同输入的json文件。所以我不得不放弃它，重写成这个。它的性能比我之前想到的解决方案要好。@SuhailSullad使用

parallelStream（）

通常会损害而不是帮助性能。并行性的开销只适用于非常非常大的数据块或非常非常大的操作。这还不够大。太棒了，但“未处理的异常类型IOException”不起作用。@SuhailSullad编译器错误指向代码的哪一部分？据我所知，我没有添加任何引发该异常的代码，因此问题也会出现在您的原始代码中。原始代码处理了

IOException

。当我试图编译上面的代码时，Eclipse会出错，说

ClassPath.from（ClassLoader.getSystemClassLoader（））

有未处理的异常。我看不出在原始代码中它是在哪里处理的。如果您需要帮助解决该错误，请查看。我给了你另一个答案。奇怪的eclipse IDE行为。无论如何，找出了问题的原因并解决了它。谢谢

String[] packageNames = { "com.example" };
LinkedHashMap<String, LinkedHashMap<String, LinkedHashMap<String, String>>> mapOfpackageMethodParameters = Arrays
    .stream(packageNames)
    .flatMap(packageName -> ClassPath
        .from(ClassLoader.getSystemClassLoader())
        .getTopLevelClassesRecursive(packageName)
        .stream())
    .filter(classInfo -> classInfo.getPackageName().endsWith("test"))
    .map(ClassInfo::load)
    .collect(Collectors.toMap(
        Class::getName,
        clazz -> Arrays
            .stream(clazz.getMethods())
            .collect(Collectors.toMap(
                Method::getName,
                method -> Arrays
                    .stream(method.getParameters())
                    .collect(Collectors.toMap(
                        Parameter::getName,
                        param -> param.getType().toString(),
                        (x, y) -> x, LinkedHashMap::new)),
                (x, y) -> x, LinkedHashMap::new)),
        (x, y) -> x, LinkedHashMap::new));