如何组合来自 Collectors.groupingBy 的结果

Question

我正在玩 Java 反射并了解有关 Stream.collect 的更多信息。

我有一个注释 MyTag，它有两个属性（id 和 type enum[Normal|Failure]）。 另外，我有一个带有 MyTag 的注释方法列表，我可以使用 Collectors.groupingBy 通过 MyTag 注释的 id 属性对这些方法进行分组：

List<Method> ml = getMethodsAnnotatedWith(anClass.getClass(),
                                           MyTag.class);
Map<String, List<Method>> map = ml.stream().collect(groupingBy(m -> {
      var ann = m.getDeclaredAnnotation(MyTag.class);
      return ann.anId();
    }, TreeMap::new, toList()));

现在我需要将生成的列表减少为一个对象，该对象仅由两个具有相同 MyTag.id 的项目组成，一个具有 MyTag.type=Normal，另一个具有 MyTag.type=Failure。所以它会产生类似 Map> 的东西。如果出现两次以上，我必须只选择第一个，记录并忽略其余的。

我怎样才能做到这一点？

Answer 1

你可以使用

Map<String, Map<Type, Method>> map = Arrays.stream(anClass.getClass().getMethods())
    .filter(m -> m.isAnnotationPresent(MyTag.class))
    .collect(groupingBy(m -> m.getDeclaredAnnotation(MyTag.class).anId(),
            TreeMap::new,
            toMap(m -> m.getDeclaredAnnotation(MyTag.class).aType(),
                  m -> m, (first, last) -> first,
                  () -> new EnumMap<>(Type.class))));

结果将注解 ID 属性映射到 Map，从 Type（枚举常量 NORMAL 和 FAILURE）映射到第一个遇到的带有匹配注解的方法。虽然“first”在迭代 Reflection 发现的方法时没有实际意义，因为它不保证任何特定的顺序。

() -> new EnumMap<>(Type.class) 映射工厂不是必需的，当您不指定工厂时，它也可以与默认使用的通用映射一起使用。但是EnumMap 将以稍微更有效的方式处理您只有两个常量要映射的情况，并且它的迭代顺序将匹配枚举常量的声明顺序。

我认为，EnumMap 比 Pair<Method, Method> 更好，后者需要记住哪个方法与“正常”相关联，哪个与“失败”相关联。适应两个以上的常数也更容易。此外，EnumMap 是内置的，不需要 3rd 方库。

Answer 2

以下示例可以很容易地适应您的代码：

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import java.util.stream.Collectors;

import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Test {

    private static final Logger logger = LoggerFactory.getLogger(Test.class);

    public static void main(String[] args) {
        List<Pair<String, String>> ml = Arrays.asList(
                Pair.of("key1", "value1"),
                Pair.of("key1", "value1"),
                Pair.of("key1", "value2"),
                Pair.of("key2", "value1"),
                Pair.of("key2", "value3"));

        Map<String, Pair<String, String>> map = ml.stream().collect(
                Collectors.groupingBy(m -> {
                    return m.getKey();
                }, TreeMap::new, Collectors.toList()))
                .entrySet()
                .stream()
                .collect(Collectors.toMap(
                        Map.Entry::getKey, e -> convert(e.getValue())));

        System.out.println(map.values());
    }

    private static Pair<String, String> convert(List<Pair<String, String>> original) {
        long count1 = original.stream().filter(e -> Objects.equals(e.getValue(), "value1")).count();
        long count2 = original.stream().filter(e -> Objects.equals(e.getValue(), "value2")).count();
        if (count1 > 1) {
            logger.warn("More than one occurrence of value1");
        }
        if (count2 > 1) {
            logger.warn("More than one occurrence of value2");
        }
        return Pair.of(count1 > 0 ? "value1" : null,
                count2 > 0 ? "value2" : null);
    }

}

• 使用方法代替 Pair
• m.getDeclaredAnnotation(MyTag.class).anId()对应pair.getKey()

以下结果打印到控制台：

01:23:27.959 [main] WARN syglass.Test2 - More than one occurrence of value1
[(value1,value2), (value1,null)]

Answer 3

首先，创建自己的MethodPair 类：

class MethodPair {
  private final Method failure;
  private final Method normal;

  public MethodPair(Method failure, Method normal) {
    this.failure = failure;
    this.normal = normal;
  }

  public Method getFailure() {
    return failure;
  }

  public Method getNormal() {
    return normal;
  }

  public MethodPair combinedWith(MethodPair other) {
    return new MethodPair(
        this.failure == null ? other.failure : this.failure,
        this.normal == null ? other.normal : this.normal)
    );
  }
}

注意combinedWith 方法。这对我们将要做的减少很有用。

使用reducing 收集器代替toList：

Map<String, MethodPair> map = ml.stream().collect(groupingBy(m -> {
  var ann = m.getDeclaredAnnotation(MyTag.class);
  return ann.anId();
}, TreeMap::new,
    Collectors.reducing(new MethodPair(null, null), method -> {
      var type = method.getDeclaredAnnotation(MyTag.class).type();
      if (type == Type.NORMAL) {
        return new MethodPair(null, method);
      } else {
        return new MethodPair(method, null);
      }
    }, MethodPair::combinedWith)
    ));

如果您可以分两步执行此操作，我建议您先创建Map<String, List<Method>>，然后将其值映射到新地图。 IMO 这更具可读性：

Map<String, List<Method>> map = ml.stream().collect(groupingBy(m -> {
  var ann = m.getDeclaredAnnotation(MyTag.class);
  return ann.anId();
}, TreeMap::new, toList()));
var result = map.entrySet().stream().collect(Collectors.toMap(entry -> entry.getKey(), entry -> {
  Method normal = null;
  Method failure = null;
  for (var m : entry.getValue()) {
    var type = m.getDeclaredAnnotation(MyTag.class).type();
    if (type == Type.NORMAL && normal == null) {
      normal = m;
    } else if (type == Type.FAILURE && failure == null) {
      failure = m;
    }
    if (normal != null && failure != null) {
      break;
    }
  }
  return new MethodPair(failure, normal);
}));