实施例

Question

我的情况是我在代码中维护了许多布尔标志。

以下是情况 -

我现在有6个标志，分别为flag1，flag2，flag3，flag4，flag5，flag6。

这些标志在程序中切换。现在，这些标志可能会增加，我不喜欢有这么多标志的代码。

我想过在嵌套类中使用布尔数组，像这样 -

    private static class Flag{

    private static boolean[] flags = new boolean[]{false,false,false,false,false,false,false};

    private static void enableFlag1(){
        flags[0] = true;
    }

    private static void disableFlag1(){
        flags[0] = true;
    } //... So on for each flag

}

但是在这里我将不得不为每个标志编写方法。我喜欢这种方法用于更少的标志，因为它从内部布尔数组表示抽象用户但是对于许多标志它似乎是一个问题。请帮助确定最佳方法是什么？

Answer 1

您可以使用EnumSet来实现此目的。

EnumSets是内部实现的long数组中的位，使用枚举的ordinal()值，这非常有效，它具有与BitSet类似的性能特征，除了更多的类型安全性和可以说更清晰。

例如，给定此枚举：

enum Features {
  FEATURE1, FEATURE2, FEATURE3
}

您可以使用适当的标志创建一个EnumSet，如下所示：

Set<Features> flags = EnumSet.of(FEATURE1);

这将允许进行功能测试：

flags.contains(FEATURE2); // false
flags.contains(FEATURE1); // true

或者，对于多个测试，您可以与第二组进行比较：

Set<Features> requiredFlags = EnumSet.of(FEATURE1, FEATURE2);

flags.containsAll(requiredFlags); // false

Set<Features> allFlags = EnumSet.allOf(Features.class);
allFlags.containsAll(requiredFlags); // true

请注意，EnumSet表现为常规可变集。因此，可以在创建集之后对其进行操作，如下所示：

Set<Features> someFlags = EnumSet.noneOf(Features.class);
someFlags.add(FEATURE1);

someFlags.equals(flags); // true
someFlags.equals(requiredFlags); // false

someFlags.add(FEATURE2);

someFlags.equals(flags); // false
someFlags.equals(requiredFlags); // true

然而，将它们视为不可变通常是个好主意，甚至可能将它们包装在Collections.unmodifiableSet()的调用中

由于EnumSet表现为常规集，因此对其执行集合操作可以很好地表达成员资格，联合，交集和差异关系。

Answer 2

使用BitSet类... 因此，您可以始终在您设置的标志之间获得良好控制的关系，而不是

实施例

final BitSet flags = new BitSet(); 
// set bit2/flag
flags.set(2);
// set bit15/flag
flags.set(15);

System.out.println("which flag did I set in flags: ");
System.out.println(flags);

Answer 3

您也可以使用EnumMap：

public class FlagMap {
    private enum Flags {
        FLAG1, FLAG2, FLAG3
    }

    private Map<Flags, Boolean> map = Collections.synchronizedMap(
        new EnumMap<Flags, Boolean>(Flags.class));

    public void setFlag(Flags flag, boolean value) {
        map.put(flag, value);
    }

    public boolean getFlag(Flags flag) {
        return map.get(flag);
    }

    public static void main(String args[]) {
        FlagMap flagMap = new FlagMap();
        // Set a flag:
        flagMap.setFlag(Flags.FLAG1, true);
        // Get a flag:
        System.out.println("Flag 1: " + flagMap.getFlag(Flags.FLAG1));
    }
}

Answer 4

一种解决方案是使用Map在单个集合中命名标记。 e.g。

Map<String, Boolean> flags = new HashMap<>();
flags.put("flagName1", true);
flags.put("flagName2", false);

boolean flag1 = flags.get("flagName1");

Answer 5

BitSet的好工作：

static final BitSet flags = new BitSet(7);

static void enableFlag(int i) {
    flags.set(i);
}

static void disableFlag(int i) {
    flags.set(i, false);
} 

static boolean checkFlag(int i) {
    return flags.get(i);
}

Answer 6

感谢所有答案。我使用了混合方法。我有一个enum说

private enum Flags{

    Flag1,Flag2,Flag3,Flag4,Flag5,Flag6;
}

除此之外，我使用了一个bitset（flagSet）。

我没有在bitset中设置硬编码索引值，而是使用Flags enum

中的索引

flagSet.get(Flags.Flag1.ordinal()) //for getting
flagSet.set(Flags.Flag1.ordinal()) //For setting

处理布尔标志的最佳方法

6 个答案:

实施例