如何获取 mapA 中的键，因为 mapB 中的键是 mapA 中键的子字符串？

Question

我这里有两张地图：

地图A

Map<String, String> mapA = new HashMap<>();
mapA.put("aaa|111|osdf", "value1");
mapA.put("bbb|222|dfsf", "value2");
...

地图B

Map<String, String> mapB = new HashMap<>();
mapB.put("aaa", "valueM");
mapB.put("bbb", "valueN");
...

如果mapB中的键是mapA中键的子字符串，现在我想获取mapA中的键，就像：

mapB.forEach((key, value) -> {
  if (mapA.containsKey(key)) {
     // This is not what I want, because key in mapB is substring of key in mapA.
     // nested loop is not suggested here.

 ​ }

})

输出

aaa|111|osdf
bbb|222|dfsf

如何获取 mapA 中的键，因为 mapB 中的键是 mapA 中键的子字符串？

Answer 1

这应该可以工作

 mapB.forEach((k, v) -> {
            String key = mapA.entrySet().stream()
                    .filter(entry -> entry.getKey().contains(k))
                    .findFirst()
                    .get()
                    .getKey();
            System.out.println(key);
        });

Answer 2

containsKey(Object key) 将检查此映射是否包含键 k 的映射，使得 (key==null ? k==null : key.equals(k)) 。但是，在您的情况下， aaa|111|osdf 或 bbb|222|dfsf 被视为单键。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapMain {

    public static void main(String[] args) {

        Map<String, String> mapA = new HashMap<>();
        mapA.put("aaa|111|osdf", "value1");
        mapA.put("bbb|222|dfsf", "value2");

        Map<String, String> mapB = new HashMap<>();
        mapB.put("aaa", "valueM");
        mapB.put("bbb", "valueN");

        mapB.forEach((k, v) -> {
            Set<String> mapAKeySet = mapA.keySet();
            mapAKeySet.stream().filter(key -> key.contains(k)).forEach(System.out::println);
        });
    }

}

Answer 3

试试这个。

public static void main(String[] args) {
    Map<String, String> mapA = new HashMap<>();
    mapA.put("aaa|111|osdf", "value1");
    mapA.put("bbb|222|dfsf", "value2");

    Map<String, String> mapB = new HashMap<>();
    mapB.put("aaa", "valueM");
    mapB.put("bbb", "valueN");
    
    for (String aKey : mapA.keySet())
        for (String bKey : mapB.keySet())
            if (aKey.contains(bKey)) {
                System.out.println(aKey);
                break;
            }
}

输出：

aaa|111|osdf
bbb|222|dfsf

或者

    mapA.keySet().stream()
        .filter(aKey -> mapB.keySet().stream()
            .anyMatch(bKey -> aKey.contains(bKey)))
        .forEach(System.out::println);

Answer 4

您可以将比较块更改为以下内容：

mapB.forEach( ( key, value ) -> {
    mapA.keySet().forEach( k -> { if( k.contains( key ) ) System.out.println( k ); } );
} );

您可以将if 条件更改为startsWith() 或String 提供并更好地满足您的需求的其他检查。

这可能多次打印一个键，具体取决于两个映射中的实际键。因此，您可以不打印，而是在 if 块内的 Set 中收集匹配的键，然后再打印。

---

使用自定义地图实现

这只确保循环转移到Map 实现中。但是，不能避免循环。我很想看到一种不使用循环键的技术。

public static void main( String[] args ){
    class CustomHashMap extends HashMap<String, String>{
        /* This method will find the matching keys. May be changed to return List<String>. */
        public String getStartingKey( String key ) {
            if( key == null || !( key instanceof String ) ) return null;
            for( String k : keySet() ) if( k.startsWith( key.toString() ) ) return k;
            return null;
        }
    };
    
    CustomHashMap mapA = new CustomHashMap();
    
    mapA.put( "aaa|111|osdf", "value1" );
    mapA.put( "bbb|222|dfsf", "value2" );
    mapA.put( "ccc|222|dfsf", "value2" );

    Map<String, String> mapB = new HashMap<>();
    mapB.put( "aaa", "valueM" );
    mapB.put( "bbb", "valueN" );

    mapB.forEach( ( key, value ) -> {
        System.out.println( mapA.getStartingKey( key ) );
    } );
}