有一张 table :

key 由 3 个后缀组成: 区域+s1+s2

region，比如US总是指定的，但其他的可以不指定，所以*将用于“all”。

例如: 对于 key = "US_A_U"value = 2，因为:

1. 尝试查找完全匹配项:在表中查找键 ("US_A_U") - 不是 发现
2. 少一步严格查找:查找键 ("US_A_*") - 找到 == 2

对于 key = "US_Q_Q"value = 3，因为:

1. 尝试查找完全匹配项:在表中查找键 ("US_Q_Q") - 不是 发现
2. 少一步严格查找:查找键 ("US_Q_*") - 未找到
3. 查找键(“US_*_Q”)- 未找到
4. 少一步严格查找:查找键 ("US_*_*") - found = 3

对于 key = "US_O_P"value = 3，因为:

1. 试图找到完全匹配:在表键(“US_O_P”)中找到 - 不是 发现
2. 少一步严格查找:查找键 ("US_O_*") - 未找到
3. 查找 key ("US_*_P") - 未找到
4. 少一步严格查找:查找键 ("US_*_*") - found = 3

所以要使用 HashMap 方法，我需要调用 4 次 map.get() 才能找到一个值，这个值太多了，因为这段代码会运行得非常非常频繁。

有没有更好或更快的解决方案？

package test;

import java.util.HashMap;

public class MainCLass {

    public static void main(String[] args) {
        // init map (assuming this code will be run only once)
        HashMap<String, String> map = new HashMap<>();
        map.put("US_A_B", "1");
        map.put("US_A_*", "2");
        map.put("US_*_*", "3");
        map.put("US_O_O", "4");
        map.put("US_*_W", "5");
        map.put("ASIA_*_*", "6");

        // now often called logic
        // incoming params, for this example hardcoded
        String reg = "US";
        String s1 = "O";
        String s2 = "P";
        String val = null;
        val = map.get(reg+"_"+s1+"_"+s2);
        if (val == null){
            val = map.get(reg+"_"+s1+"_*");
            if (val == null){
                val = map.get(reg+"_"+"*_"+s2);
                if (val == null){
                    val = map.get(reg+"_*_*");
                }
            }
        }
        System.out.println(val);
    }
}

更新:我需要补充一点，总是有 3 个传入参数(区域、s1、s2)。每个参数永远不会等于 "*" 并且永远不会为空，所以完整的 key 总是像 US_J_K (而不是 US_*_K等等)

所以通过这 3 个参数，我需要从 init 表中找到正确的值。

最佳答案

您可以尝试创建一层 map ，例如

Map<String, Map<String, Map<String, String>>> map;

在这个映射中，第一个键是region，第二个键是s1，第三个键是s2。这将允许轻松地独立搜索区域、s1 和 s2。

编辑:

搜索“US_O_P”的示例用法

public static void main(String[] args) {
    RegionMap map = new RegionMap();
    String region = "US";
    String s1 = "O";
    String s2 = "P";
    String val = map.search(region, s1, s2);
    System.out.println(val);
}

public class RegionMap {
    private Map<String, Map<String, Map<String, String>>> regionMap;

    public RegionMap() {
        init();
    }

    public String search(String region, String s1, String s2) {
        String val = searchS1(regionMap.get(region), s1, s2);
        if (val == null) {
            val = searchS1(regionMap.get("*"), s1, s2);
        }
        return val;
    }

    private String searchS1(Map<String, Map<String, String>> s1Map, String s1, String s2) {
        if (s1Map == null) {
            return null;
        }
        String val = searchS2(s1Map.get(s1), s2);
        if (val == null) {
            val = searchS2(s1Map.get("*"), s2);
        }
        return val;
    }

    private String searchS2(Map<String, String> s2Map, String s2) {
        if (s2Map == null) {
            return null;
        }
        String val = s2Map.get(s2);
        if (val == null) {
            val = s2Map.get("*");
        }
        return val;
    }

    private void init() {
        regionMap = new HashMap<>();
        addEntry("US", "A", "B", "1");
        addEntry("US", "A", "*", "2");
        addEntry("US", "*", "*", "3");
        addEntry("US", "O", "O", "4");
        addEntry("US", "*", "W", "5");
        addEntry("ASIA", "*", "*", "6");
    }

    private void addEntry(String region, String s1, String s2, String value) {
        Map<String, Map<String, String>> s1Map = regionMap.get(region);
        if (s1Map == null) {
            s1Map = new HashMap<>();
            regionMap.put(region, s1Map);
        }

        Map<String, String> s2Map = s1Map.get(s1);
        if (s2Map == null) {
            s2Map = new HashMap<>();
            s1Map.put(s1, s2Map);
        }

        s2Map.put(s2, value);
    }
}

编辑: 基准测试结果

我多次运行搜索“US_O_P”的测试，发现 1,000,000,000 次搜索的结果如下

Original: 9.7334702479 seconds
Tiered: 2.471287074 seconds

以下为基准代码

public class RegionMapOrig {
    private Map<String, String> map;

    public RegionMapOrig() {
        init();
    }

    private void init() {
        map = new HashMap<>();
        map.put("US_A_B", "1");
        map.put("US_A_*", "2");
        map.put("US_*_*", "3");
        map.put("US_O_O", "4");
        map.put("US_*_W", "5");
        map.put("ASIA_*_*", "6");
    }

    public String search(String reg, String s1, String s2) {
        String val = null;
        val = map.get(reg + "_" + s1 + "_" + s2);
        if (val == null) {
            val = map.get(reg + "_" + s1 + "_*");
            if (val == null) {
                val = map.get(reg + "_" + "*_" + s2);
                if (val == null) {
                    val = map.get(reg + "_*_*");
                }
            }
        }
        return val;
    }
}

private static final int N = 1000000000;

public static void main(String[] args) {
    String region = "US";
    String s1 = "O";
    String s2 = "P";

    testOrig(region, s1, s2);
    test(region, s1, s2);
}

private static void testOrig(String region, String s1, String s2) {
    RegionMapOrig map = new RegionMapOrig();

    long start = System.nanoTime();

    for (int i = 0; i < N; ++i) {
        String val = map.search(region, s1, s2);
    }

    long end = System.nanoTime();
    System.out.println((end - start) / 10E9);
}

private static void test(String region, String s1, String s2) {
    RegionMap map = new RegionMap();

    long start = System.nanoTime();

    for (int i = 0; i < N; ++i) {
        String val = map.search(region, s1, s2);
    }

    long end = System.nanoTime();
    System.out.println((end - start) / 10E9);
}

多次运行此代码产生了相同的结果。然而，这个基准很简单，可能不是决定性的。要真正测试您的结果，您需要使用代表典型值的真实数据集来分析性能。我相信您的性能问题可能在于您的字符串连接，而不是对 map 的调用次数。我的可能表现更好的另一个原因是我的内部 map 可能被缓存，使多次检索更快。

编辑:基准更新

通过删除字符串连接进行进一步调查后，您的原始代码改进了显示这些结果:

Orginal (no concatentation): 1.2068575417 seconds
Tiered: 2.2982665873 seconds

代码改动是:

public String searchNoCat(String cache1, String cache2, String cache3,  String cache4) {
    String val = null;
    val = map.get(cache1);
    if (val == null) {
        val = map.get(cache2);
        if (val == null) {
            val = map.get(cache3);
            if (val == null) {
                val = map.get(cache4);
            }
        }
    }
    return val;
}

private static void testOrigNoCat(String region, String s1, String s2) {
    RegionMapOrig map = new RegionMapOrig();

    String cache1 = region + "_" + s1 + "_" + s2;
    String cache2 = region + "_" + s1 + "_*";
    String cache3 = region + "_" + "*_" + s2;
    String cache4 = region + "_*_*";

    long start = System.nanoTime();

    for (int i = 0; i < N; ++i) {
        String val = map.searchNoCat(cache1, cache2, cache3, cache4);
    }

    long end = System.nanoTime();
    System.out.println((end - start) / 10E9);
}

但是，问题仍然在于如何有效地缓存这些值或减少通用输入的连接数。我不知道有什么有效的方法可以做到这一点。因此，我认为分层映射是一种避免连接问题的有效解决方案。

关于java - 从具有可变键的表中查找值，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41194632/