Question

我必须在下面为我的需要选择一个数据结构我正在解释有以下值的条件

abc,def,rty,ytr,dft   which all are map to row R1B1 (actully key is combination of R1+B1)
abEERc,dFFFef,rGGty   which all are map to row R1B2 (actully key is combination of R1+B2)

  KEY                      VALUE
abc,def,rty,ytr,dft --->    R1B1
abEERc,dFFFef,rGGty --->    R1B2

现在，例如，让我们说，如果我得到ytr，那么我将能够检索R1B1 或者，让我们说，我得到的值rGGty然后我就可以检索R1B2

现在的情况是问题是搜索，复杂性以及事情必须顺序进行所花费的时间

例如，它会首先选择要搜索ytr的第一行，它会先与abc匹配，但不匹配，然后必须与def匹配再次匹配，然后它将与rty匹配，这将不匹配，然后它将最终与ytr匹配，最后它将找到关键R1B1最终

类似地，如果需要搜索第二个字符串，请说rGGty然后它将扫描第一行，它将找不到该值，然后搜索将继续到第二行，也在第三行中的第二行会得到rGGty作为元素，然后它会将R1B2检索为值

让我们说，如果将这个东西放在地图中，那么序列搜索将继续关键，然后只有我们才能找到相应的值

请各位建议哪些是我能在java中实现的最佳数据结构，我必须在非常快的时间内搜索关键项以找到相应的值，这也不会影响性能，那种数据结构性能应该很高

请告知人们

Answer 1

可以使用HashMap在O（1）中访问键值对。但是，如果使用HashMap<String, String>，那么更新值将会很痛苦，因为字符串是不可变的。这意味着您必须检查所有条目集，如果值匹配则更新它。因此，您可以为值创建一个辅助类，并让所有键指向此类的实例。这是一个包含最重要功能的存根，我想你可以自己添加其余部分。

public class MyDataStructure {

  private Map<String, MyValue> key_value = new HashMap<String, MyValue>();
  private Map<String, MyValue> value_MyValue = new HashMap<String, MyValue>();

  public void set(String key, String value) {
    MyValue v = value_MyValue.get(value);
    if (v == null) { // should rarely happen, could check with containsKey
      v = new MyValue(value);
      value_MyValue.put(v);
    }
    key_value.put(key, v);
  }

  public String get(String key) {
    return key_value.get(key).getValue(); // key might not exist
  }

  public String changeValue(String oldValue, String newValue) {
    MyValue v = value_MyValue.remove(oldValue); // oldValue might not exist
    v.setValue(newValue); 
    value_MyValue.put(newValue, v);
    // will not work if newValue already exists... then you will have to merge
  }

  private class MyValue() {
    private String value;
    public MyValue(String value) {
      this.value = value;
    }
    public String getValue() {
      return value;
    }
    public void setValue(String value) {
      this.value = value;
    }
  }
}

Answer 2

我认为最好保持简单，直到表现不佳表明需要某种改进。即使许多映射值是相同的字符串，也应该没问题，因为Java只在堆中存储一个副本。如果映射到单个字符串的键集变得非常大，则可以通过执行两次查找来进行一些性能改进 - 首先确定集合成员资格，然后再检索与集合关联的密钥的值。这很容易实现。目前，这是一种直接的方法：

import java.util.*;

public class HashMapDemo {

    static HashMap<String, String> map = new HashMap<String, String>();

    public static void lookup(String key, String value) {
        if (map.get(key) == value) {
            System.out.println(key + " lookup ok");
        } else {
            System.out.println(key + " lookup produced" + map.get(key));
        }
    }

    public static void main(String[] args) {
        // requirements:
        // abc,def,rty,ytr,dft ---> R1B1
        // abEERc,dFFFef,rGGty ---> abEERc

        Set<String> kset1 = new HashSet<String>(Arrays.asList("abc", "def",
                "rty", "ytr", "dft"));

        Set<String> kset2 = new HashSet<String>(Arrays.asList("abEERc",
                "dFFFef", "rGGty"));

        for (String s : kset1) {
            map.put(s, "R1B1");
        }

        for (String s : kset2) {
            map.put(s, "abEERc");
        }

        // testing value lookup with key

        for (String s : kset1) {
            lookup(s, "R1B1");
        }

        // prints:
        // abc lookup ok
        // dft lookup ok
        // def lookup ok
        // rty lookup ok
        // ytr lookup ok

        for (String s : kset2) {
            lookup(s, "abEERc");
        }

        // prints:
        // rGGty lookup ok
        // abEERc lookup ok
        // dFFFef lookup ok

        // change key "R1B1" to "XYZ"

        for (String s : kset1) {
            map.put(s, "XYZ");
        }

        // test the change

        for (String s : kset1) {
            lookup(s, "XYZ");
        }

        // prints:
        // abc lookup ok
        // dft lookup ok
        // def lookup ok
        // rty lookup ok
        // ytr lookup ok

    }
}

在java

2 个答案: