Java 何时使用多个链接的哈希映射与元组值类型的哈希映射

我目前有一个解决方案，使用两个哈希映射和匹配的键将值链接在一起（即键：前缀长度，值：子网掩码/可用地址数）

这里是否存在一个重要的设计问题？使用元组值类型将这些hashmap合并在一起会更好吗？这会增加两个简单映射的复杂性吗类似的问题给出了两种选择，但似乎没有给出何时使用其中一种而不是另一种的场景

以下实施示例：

private static HashMap<Integer, Integer> prefixAndNumberOfAddresses;
private static HashMap<Integer, String> prefixAndSubnets;

static {
    prefixAndNumberOfAddresses = new HashMap<Integer, Integer>();
    prefixAndNumberOfAddresses.put(8, 16777214);
    prefixAndNumberOfAddresses.put(9, 8388606);
    prefixAndNumberOfAddresses.put(10, 4194302);
    prefixAndNumberOfAddresses.put(11, 2097150);
    prefixAndNumberOfAddresses.put(12, 1048574);
    prefixAndNumberOfAddresses.put(13, 524286);
    prefixAndNumberOfAddresses.put(14, 262142);
    prefixAndNumberOfAddresses.put(15, 131070);
    prefixAndNumberOfAddresses.put(16, 65534);
    prefixAndNumberOfAddresses.put(17, 32766);
    prefixAndNumberOfAddresses.put(18, 16382);
    prefixAndNumberOfAddresses.put(19, 8190);
    prefixAndNumberOfAddresses.put(20, 4094);
    prefixAndNumberOfAddresses.put(21, 2046);
    prefixAndNumberOfAddresses.put(22, 1022);
    prefixAndNumberOfAddresses.put(23, 510);
    prefixAndNumberOfAddresses.put(24, 254);
    prefixAndNumberOfAddresses.put(25, 126);
    prefixAndNumberOfAddresses.put(26, 62);
    prefixAndNumberOfAddresses.put(27, 30);
    prefixAndNumberOfAddresses.put(28, 14);
    prefixAndNumberOfAddresses.put(29, 6);
    prefixAndNumberOfAddresses.put(30, 2);
}

static {
    prefixAndSubnets = new HashMap<Integer, String>();
    prefixAndSubnets.put(8, "255.0.0.0");
    prefixAndSubnets.put(9, "255.128.0.0");
    prefixAndSubnets.put(10, "255.192.0.0");
    prefixAndSubnets.put(11, "255.224.0.0");
    prefixAndSubnets.put(12, "255.240.0.0");
    prefixAndSubnets.put(13, "255.248.0.0");
    prefixAndSubnets.put(14, "255.252.0.0");
    prefixAndSubnets.put(15, "255.254.0.0");
    prefixAndSubnets.put(16, "255.255.0.0");
    prefixAndSubnets.put(17, "255.255.128.0");
    prefixAndSubnets.put(18, "255.255.192.0");
    prefixAndSubnets.put(19, "255.255.224.0");
    prefixAndSubnets.put(20, "255.255.240.0");
    prefixAndSubnets.put(21, "255.255.248.0");
    prefixAndSubnets.put(22, "255.255.252.0");
    prefixAndSubnets.put(23, "255.255.254.0");
    prefixAndSubnets.put(24, "255.255.255.0");
    prefixAndSubnets.put(25, "255.255.255.128");
    prefixAndSubnets.put(26, "255.255.255.192");
    prefixAndSubnets.put(27, "255.255.255.224");
    prefixAndSubnets.put(28, "255.255.255.240");
    prefixAndSubnets.put(29, "255.255.255.248");
    prefixAndSubnets.put(30, "255.255.255.252");
}

私有静态HashMap前缀和numberOfAddresses；
专用静态哈希映射前缀和子网；
静止的{
prefixAndNumberOfAddresses=新HashMap（）；
前缀和numberOfAddresses.put（816777214）；
prefixAndNumberOfAddresses.put（98388606）；
前缀和numberOfAddresses.put（104194302）；
前缀和numberOfAddresses.put（112097150）；
前缀和numberOfAddresses.put（121048574）；
前缀和numberOfAddresses.put（13524286）；
前缀和numberofAddresses.put（14262142）；
前缀和numberOfAddresses.put（1513070）；
前缀和numberOfAddresses.put（1665534）；
前缀和numberOfAddresses.put（1732766）；
前缀和numberofAddresses.put（1816382）；
前缀和numberofAddresses.put（198190）；
前缀和numberofAddresses.put（204094）；
前缀和numberofAddresses.put（212046）；
前缀和numberofAddresses.put（221022）；
前缀和numberOfAddresses.put（23510）；
前缀和numberOfAddresses.put（24254）；
前缀和numberOfAddresses.put（25126）；
前缀和numberofAddresses.put（26,62）；
前缀和numberofAddresses.put（27,30）；
前缀和numberOfAddresses.put（28,14）；
前缀和numberofAddresses.put（29,6）；
前缀和numberofAddresses.put（30,2）；
}
静止的{
prefixAndSubnets=新HashMap（）；
前缀和子网。put（8，“255.0.0.0”）；
前缀和子网。put（9，“255.128.0.0”）；
前缀和子网。put（10，“255.192.0.0”）；
前缀和子网。put（11，“255.224.0.0”）；
前缀和子网。put（12，“255.240.0.0”）；
前缀和子网。put（13，“255.248.0.0”）；
前缀和子网。put（14，“255.252.0.0”）；
前缀和子网。put（15，“255.254.0.0”）；
前缀和子网。put（16，“255.255.0.0”）；
前缀和子网。put（17，“255.255.128.0”）；
前缀和子网。put（18，“255.255.192.0”）；
前缀和子网。put（19，“255.255.224.0”）；
前缀和子网。put（20，“255.255.240.0”）；
前缀和子网。put（21，“255.255.248.0”）；
前缀和子网。put（22，“255.255.252.0”）；
前缀和子网。put（23，“255.255.254.0”）；
prefixAndSubnets.put（24，“255.255.255.0”）；
prefixAndSubnets.put（25，“255.255.255.128”）；
prefixAndSubnets.put（26，“255.255.255.192”）；
prefixAndSubnets.put（27，“255.255.255.224”）；
前缀和子网。put（28，“255.255.255.240”）；
前缀和子网。put（29，“255.255.255.248”）；
前缀和子网。put（30，“255.255.255.252”）；
}

在这种情况下，最好使用一个值为

元组的
HashMap

原因很简单，如果您使用两个
HashMap
：

当查询一个键的完整数据时，必须对两个
HashMap
如果要打印所有子网掩码/地址数，必须确保两个
HashMap
的大小相同
两个独立的
HashMap
s非常麻烦且容易出错。将两者合并到一个
HashMap
中，保存一个查找和一些代码行

正如我在评论中所说的，如果您需要非常频繁地访问该查找表（每秒一次，或每秒100次），那么使用该表查找可能会更好。否则，您可以采用编程方法。当然，它有点慢，但它肯定更优雅，更面向对象

public class SubnetMask {

    private int prefix;

    public SubnetMask(int prefix) {
        if (prefix < 8 || prefix > 30) {
            throw new IllegalArgumentException("Prefix must be in [8;32]");
        }
        this.prefix = prefix;
    }

    public long getNrOfAvailableAddresses() {
        return (long) Math.pow(2, 32 - this.prefix) - 2;
    }

    // returns something like "255.255.192.0"
    public String getSubnetMaskRepresentation() {
        long bits = 0xffffffff ^ (1 << 32 - this.prefix) - 1;
        return String.format("%d.%d.%d.%d", 
                 (bits & 0x0000000000ff000000L) >> 24, 
                 (bits & 0x0000000000ff0000) >> 16, 
                 (bits & 0x0000000000ff00) >> 8, bits & 0xff);
    }
}

公共类子网掩码{
私有int前缀；
公共子网掩码（int前缀）{
如果（前缀<8 | |前缀>30）{
抛出新的IllegalArgumentException（“前缀必须在[8；32]中”）；
}
this.prefix=前缀；
}
公共长getNrOfAvailableAddresses（）{
return（long）Math.pow（2，32-this.prefix）-2；
}
//返回类似“255.255.192.0”的内容
公共字符串getSubnetMaskRepresentation（）{
长位=0xFFFFFF^（1>24，
（位&0x0000000000ff0000）>>16，
（位&0x0000000000ff00）>>8，位&0xff）；
}
}

注：x.x.x.x表示法的翻译取自gma的答案

PPS.：Intellij Idea建议简化
长位=…
语句。不要这样做，它似乎给出了一个错误的结果。
最好编写一个合适的类，而不是使用元组。您甚至不需要hashmap。适当的类可以足够智能，在您将前缀传递给其构造函数后，动态计算可用地址和子网掩码。当然，hashmap会快得多，但它的代码也要多得多。