Question

您好我想在ENUM中提供fromValue（）函数。请您提供宝贵的建议，我应该选择哪种方法： -

这里我们每次迭代ENUM值并返回匹配的结果。



    public enum DAY {
        SUNDAY("sunday"),
        MONDAY("monday"),
        TUESDAY("tuesday"),
        UNKNOWN("unknown");

        private final String value;

        DAY(final String value) {
            this.value = value;
        }

        public String value() {
            return value;
        }

        public static DAY fromValue(final String value) {
            return Stream.of(DAY.values())
                    .filter( day -> day.value().equals(value))
                    .findAny()
                    .orElse(UNKNOWN);
        }
    }

在这种方法中，我们使用静态块创建键值映射，并返回值而不进行迭代。但在这里我们需要使用“静态块”

    public enum DAY {
        SUNDAY("sunday"),
        MONDAY("monday"),
        TUESDAY("tuesday"),
        UNKNOWN("unknown");

        private final String value;

        DAY(final String value) {
            this.value = value;
        }

        public String value() {
            return value;
        }

        public static DAY fromValue(final String value) {
            return Stream.of(DAY.values())
                    .filter( day -> day.value().equals(value))
                    .findAny()
                    .orElse(UNKNOWN);
        }
    }

Answer 1

使用内置的valueOf（）函数 -

public static DAY fromValue(final String value) {
    try {
        return DAY.valueOf(value.toUpperCase());
    }
    catch (IllegalArgumentException e) { 
        return UNKNOWN;
    }
}

Answer 2

我只是保持代码简单并实现fromValue()迭代values()数组：

 public static Day fromValue(final String value) {
     for (Day day: values()) {
         if (day.value.equals(value)) {
             return day;
         }
     }
     return UNKNOWN;
  }

在正常大小的枚举中，与将值存储在static映射中的解决方案相比，您不会在此实现中看到任何明显的性能差异。如果您担心性能问题，首先应该衡量它。只有在识别出代码库的这一部分后，才能开始“优化”它的性能瓶颈。

上述代码可以通过仅调用values()（在引擎盖下进行数组克隆）并将数组存储在static变量中来“优化”一点：

private static Day[] VALUES = values();

Answer 3

采用第二种方法进行一点修改。


public enum DAY {

    SUNDAY("sunday"),
    MONDAY("monday"),
    TUESDAY("tuesday"),
    UNKNOWN("unknown");

    private final String value;

    DAY(final String value) {
        this.value = value;
    }

    private static final Map<String, DAY> VALUE_TO_TYPE = Stream.of(DAY.values()).collect(Collectors.toMap(d -> d.value, d -> d));

    public String value() {
        return value;
    }

   public static Optional<DAY> fromValue(final String value) {
       return Optional.ofNullable(VALUE_TO_TYPE.get(value));
   }
}

Answer 4

我更喜欢第一种方法，因为它更清洁。

当您为不同的键设置相同的值时，第二种方法可能会失败。在这种情况下，您将不得不更改地图构建逻辑。第一种方法只会返回第一个匹配的密钥。

通过将值保存为map，您没有取消搜索操作，因为Java在内部搜索地图中的键

Answer 5

选项2的控制流程如果将sops添加到构造函数和静态块，则获得的输出：

conts sunday
conts monday
星期二 conts unknown 静态bl

因此，除非您对静态块有所了解，否则第二个选项可能会更高效。

我应该选择哪种方法fromValue（）函数枚举

5 个答案: