在java中选择值列表的数据结构

Question

我有一张地图，如下图所示，其中有一个键，值的类型为List：

Map<String, List<String> newdatamap = new HashMap<>();
map.put ("RtyName", Arrays.asList("wpn", "wpfnb", "dgeft", "xbthy"));
map.put ("rtyRate", Arrays.asList("dd", "ww", "trrty", "httyure"))

我想在之前的地图上再添加一个地图，这样就有一个键，它的值就是上面的地图。这是正确的数据结构吗？我们如何实现它？

我想要像下面这样的东西

Key         Value

B1          RtyName  ----> "weepn", "weepfnb", "eedgeft", "xbteehy"
            rtyRate ----->"deed", "ww", "terrty", "hteetyure"



B2          RtyName  ----> "SSSweepn", "wpefSSSnb", "GGeGdgeft", "xbteYYYYhy"
            rtyRate ----->"WWded", "wTeTYw", "YYYYtrerty", "IIIehttyure"

如上所示，仅向映射引入了一个新键，其值为上一个映射。

所以它就像一张地图

Map<B1 , RtyName>
Map<B2 ,rtyRate>

付款人nae包含如下值的列表：

 RtyName  ----> "SSSweepn", "wpefSSSnb", "GGeGdgeft", "xbteYYYYhy"
  rtyRate ----->"deed", "ww", "terrty", "hteetyure"

因此，在上面的结构中，复杂性将很低，因为在B1的末尾，我必须搜索将是RtyName的键，并根据付款人名称进一步搜索将是“wpn”、“wpfnb”、“dgeft”、“xbthy”的值

请告知地图的最佳位置，或者是否有其他更好的数据结构来获取此信息。

我脑海中浮现的一个数据结构是番石榴表

  final Table<String, String, List<String>> values = HashBasedTable.create();
values.put("B1", "RtyName", Lists.newArrayList("weepn", "weepfnb", "eedgeft", "xbteehy"));
System.out.println(values.get("B1", "RtyName")); // prints the list

我的目标是，我可以拥有的任何数据结构中，与B1相比，我将获得Rtyname，对于Rtyname，我将获得可能的值列表




Answer 1

正如你所要求的：

您只需定义一个类，ABC，在本例中，正如您所建议的那样，它包含两个列表，RtyName和rtyRate列表：

public class ABC {
    private List<String> RtyName;
    private List<String> rtyRate;

    public ABC(List<String> RtyName, List<String> rtyRate) {
        setRtyNames(RtyName);
        setRtyRates(rtyRate);
    }

    public void setRtyNames(List<String> RtyName) {
        this.RtyName = RtyName;
    }

    public List<String> getRtyNames() {
        return this.RtyName;
    }

    public void setRtyRates(List<String> rtyRate) {
        this.rtyRate = rtyRate;
    }

    public List<String> getRtyRates() {
        return this.rtyRate;
    }
}

该类就绪后，可以将地图定义更改为：

Map<String, ABC> newdatamap = new HashMap<>();

并像之前一样为其分配新的值，而不是将这些列表嵌套在另一个映射中，并将此映射放入外部映射，而是创建一个新的ABC实例，提供两个列表作为输入参数，并将生成的ABC对象放入映射（正式称为外部映射）：

List<String> RtyName = Arrays.asList("wpn", "wpfnb", "dgeft", "xbthy");
List<String> rtyRate = Arrays.asList("dd", "ww", "trrty", "httyure");
newdatamap.put("B1", new ABC(RtyName, rtyRate));

您还可以将这些列表直接指定为输入参数：

newdatamap.put("B2", new ABC(Arrays.asList("SSSweepn", "wpefSSSnb", "GGeGdgeft", "xbteYYYYhy"), 
                             Arrays.asList("WWded", "wTeTYw", "YYYYtrerty", "IIIehttyure"));

现在，只需调用get（String）即可检索条目，就像您以前所做的那样：

ABC data = newdatamap.get("B1);

您还可以直接检索其中一个列表，如：

List<String> RtyNames = newdatamap.get("B1").getRtyNames();

在我看来，这是一种同时管理和阅读更容易的方式。除此之外，您还获得了运行时安全性，因为您不会在RtyName或rtyRate中遇到最终的键入错误。

更新以重新设计

如果RtyName条目和rtyRate条目总是齐头并进，f.e.wpn是名称，dd是分配的速率，将这些字段组合在一起是有意义的。因此，您可以重构代码，进一步减少一个列表，并引入一个新类：

public class RtyEntry {
    private String name;
    private String rate;

    public RtyEntry(String name, String rate) {
        setName(name);
        setRate(rate);
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setRate(String rate) {
        this.rate = rate;
    }

    public String getRate() {
        return this.rate;
    }
}

如果现在将ABC更改为仅包含一个RtyEntry对象列表，如下所示：

public class ABC {
    private List<RtyEntry> rtyEntries;

    public ABC(List<RtyEntry> rtyEntries) {
        this.rtyEntries = rtyEntries;
    }

    public ABC() {
        this.rtyEntries = new ArrayList<>();
    }

    public void setRtyEntries(List<RtyEntry> rtyEntries) {
        this.rtyEntries = rtyEntries;
    }

    public List<RtyEntry> getRtyEntries() {
        return this.rtyEntries;
    }

    // convenience methods

    public void addRtyEntry(RtyEntry entry) {
        this.rtyEntries.add(entry);
    }
}

现在，创建将更改为：

RtyEntry entry1 = new RtyEntry("wpn", "dd");
List<RtyEntry> entries = Arrays.asList(entry1, ...);
newdatamap.put("B1", new ABC(entries));

然后，您还可以分配这样的新条目：

newdatamap.get("B1").addRtyEntry(new RtyEntry("wpfnb", "ww"));

检索条目也更改为重构：

ABC data = newdatamap.get("B1");
List<RtyEntry> entries = data.getRtyEntries();
for (RtyEntry entry : entries) {
    System.out.println(entry.getName() + " has a rate of: " + entry.getRate());
}

当然，您也可以通过以下方式直接检索列表：

List<RtyEntry> entries = newdatamap.get("B1").getRtyEntries();

和以前一样。

Answer 2

我会这样做：

Map<Integer, List<String>> dataMap = new HashMap<>();
dataMap.put("B1".hashCode()+"RtyName".hashCode(), Arrays.asList("weepn", "weepfnb", "eedgeft", "xbteehy"));
dataMap.put("B1".hashCode()+"rtyRate".hashCode(), Arrays.asList("deed", "ww", "terrty", "hteetyure"));
dataMap.put("B2".hashCode()+"RtyName".hashCode(), Arrays.asList("SSSweepn", "wpefSSSnb", "GGeGdgeft", "xbteYYYYhy"));
dataMap.put("B2".hashCode()+"rtyRate".hashCode(), Arrays.asList("WWded", "wTeTYw", "YYYYtrerty", "IIIehttyure"));

这将代表：

B1, RtyName  ----> "weepn", "weepfnb", "eedgeft", "xbteehy"
B1, rtyRate ----->"deed", "ww", "terrty", "hteetyure"

B2, RtyName  ----> "SSSweepn", "wpefSSSnb", "GGeGdgeft", "xbteYYYYhy"
B2, rtyRate ----->"WWded", "wTeTYw", "YYYYtrerty", "IIIehttyure"

请注意，hashCode只是String类中的一个方便函数，可以满足我的需要。如果您愿意，您可以使用自己的滚动键返回字符串键（或者其他任何键）。

实际上，由于您的原始方法不需要与订单无关的函数，您甚至可以连接String键作为新键使用：

dataMap.put("B1"+"RtyName", Arrays.asList(/*your list here*/));

这比第一种方法不太方便（在编程上也没有那么好），但仍然比嵌套Map类好得多。（并且在输出时比hashCode更容易识别键。）

如果希望每个列表值映射到键，或者反过来映射到键，则需要第二个映射：

Map<List<String>, String> valueMap = new HashMap<>(); //New map for value->key 
for(String key: dataMap.keySet()) //Get all keys
    valueMap.put(dataMap.get(key), key); //Create mapping value->key

如果希望值列表中的每个字符串项映射到键，或者反过来映射到键，则需要第二个映射：

Map<String, String> itemMap = new HashMap<>(); //New map for item->key mapping
    for(String key: dataMap.keySet()) //Get all keys and iterate through
        for(String item: dataMap.get(key)) //For each item in your value list
            itemMap.put(item, key); //Create new mapping item->key