Question

使用Java 8，我找到了一种从值获取枚举的常用方法，它使用Arrays.stream对所有枚举值进行过滤，但最近，我遇到了另一种方法，{ {1}}，彼此之间更好的方式是什么？为什么？还有另一种更好的方法吗？

示例：

Stream.of

Answer 1

Stream.of实际上正在使用Arrays.stream。

public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

所以你可以直接使用Arrays.stream。

Answer 2

答案都不是。最干净的1337方式是：

public enum Foo {

    BAR_1("Bar 1"),
    BAR_2("Bar 2");

    private static class Holder {
        static Map<String, Foo> map = new HashMap<String, Foo>();
    }

    private String friendlyValue;

    Foo(String friendlyValue){
        this.friendlyValue = friendlyValue;
        Holder.map.put(friendlyValue, this);
    }

    public String getFriendlyValue() {
        return friendlyValue;
    }

    public static Foo fromFriendlyValue(String friendlyValue){
        return Holder.map.get(friendlyValue);
    }
}

fromFriendlyValue()的这种实现具有O(1)时间复杂度 - 即无论枚举中的实例数量多大，它都会在恒定时间内执行。

这里的功夫是使用Initialization-on-demand holder idiom，它在保持封装的同时巧妙地解决了枚举的初始化规则问题。

Answer 3

public enum Foo {

  BAR_1("Bar 1"),
  BAR_2("Bar 2");

  private static class Holder {
    static Map<String, Foo> map = new HashMap<String, Foo>()
       {{
         for(Foo f:Foo.values())
         {
            put(f.getFriendlyValue(),f);
         }
       }};
  }

  private String friendlyValue;

  Foo(String friendlyValue){
    this.friendlyValue = friendlyValue;
  }

  public String getFriendlyValue() {
    return friendlyValue;
  }

  public static Foo fromFriendlyValue(String friendlyValue){
    return Holder.map.get(friendlyValue);
  }
}

这个懒惰的初始化，不像@ bohemian的解决方案。这里的魔力是一个扩展hashmap的匿名类，执行其anynymous构造函数将Foo的所有值循环到地图中。

虽然对于大多数枚举（其常量非常有限），最简单的解决方案就是将它们全部循环。

public enum Foo {

  BAR_1("Bar 1"),
  BAR_2("Bar 2");

  private String friendlyValue;

  Foo(String friendlyValue){
    this.friendlyValue = friendlyValue;
  }

  public String getFriendlyValue() {
    return friendlyValue;
  }

  public static Foo fromFriendlyValue(String friendlyValue){
    for(Foo f:Foo.values())
    {
      if(f.getFriendlyValue().equals(friendlyValue))
          return f;
    }
    return null;
  }
}

由于仅仅进行比较的成本对于小型枚举来说几乎没有。

Stream.of VS Arrays.stream从值中获取枚举

3 个答案: