将集合映射到所有组合的列表

使用递归！因此，在递归的每个级别，您都会查看映射中的另一个键。以迭代方式将 for 该键中的元素添加到要添加到列表中的当前映射中。keyset()Set<V>

你可以把它想象成一棵树。在根节点上，您有一个空列表。然后，树的每个后续级别都表示从第一个集合中获取哪个元素的选择。ii

下面是代码以及包含测试用例的 main 方法：

import java.util.*;

public class Test {
    // method called to generate combinations using map, putting the combinations in list
    public static <K,V> void combinations( Map<K,Set<V>> map, List<Map<K,V>> list ) {
        recurse( map, new LinkedList<K>( map.keySet() ).listIterator(), new HashMap<K,V>(), list );
    }

    // helper method to do the recursion
    private static <K,V> void recurse( Map<K,Set<V>> map, ListIterator<K> iter, Map<K,V> cur, List<Map<K,V>> list ) {
            // we're at a leaf node in the recursion tree, add solution to list
        if( !iter.hasNext() ) {
            Map<K,V> entry = new HashMap<K,V>();

            for( K key : cur.keySet() ) {
                entry.put( key, cur.get( key ) );
            }

            list.add( entry );
        } else {
            K key = iter.next();
            Set<V> set = map.get( key );

            for( V value : set ) {
                cur.put( key, value );
                recurse( map, iter, cur, list );
                cur.remove( key );
            }

            iter.previous();
        }
    }

    public static void main( String[] args ) {
        Map<Integer,Set<Integer>> map = new HashMap<Integer,Set<Integer>>() {{
            put( 1, new HashSet<Integer>() {{
                add( 11 );
                add( 12 );
            }} );
            put( 2, new HashSet<Integer>() {{
                add( 21 );
                add( 22 );
                add( 23 );
            }} );
            put( 3, new HashSet<Integer>() {{
                add( 31 );
            }} );
        }};
        List<Map<Integer,Integer>> list = new LinkedList<Map<Integer,Integer>>();
        combinations( map, list );

        for( Map<Integer,Integer> combination : list ) {
            System.out.println( combination );
        }
    }
}

提示：使用递归生成组合“树”。

编辑：好吧，我有一些空闲时间，并决定给它一个机会：

/**
 * 
 * @param <K> The type of the key
 * @param <V> The type of the value
 * @param index The index of the current key to inspect
 * @param current The current map being built by recursion
 * @param map The original input
 * @param list The result
 */ 
public static <K, V> void Combine(int index, Map<K, V> current, 
                                  Map<K, Set<V>> map, 
                                  List<Map<K, V>> list) {
    
    if(index == map.size()) { // if we have gone through all keys in the map
        Map<K, V> newMap = new HashMap<K, V>();
        System.out.println(current);
        for(K key: current.keySet()) {          // copy contents to new map.    
            newMap.put(key, current.get((K)key));               
        }           
        list.add(newMap); // add to result.
    } else {
        Object currentKey = map.keySet().toArray()[index]; // take the current key
        for(V value: map.get(currentKey)) {
            current.put((K)currentKey, value); // put each value into the temporary map
            Combine(index + 1, current, map, list); // recursive call
            current.remove(currentKey); // discard and try a new value
        }
    }
}

我已经测试了一些案例，我认为这是正确的。让我知道。您可以从另一个方法调用它，该方法仅采用输入，创建默认参数，并作为输出返回。mapindexcurrentlistlist

编辑小型 Java 8+ 更新

public static <K, V> void combine(int index, Map<K, V> current, Map<K, List<V>> map, List<Map<K, V>> list) {

    if (index == map.size()) { // if we have gone through all keys in the map
        System.out.println(current);
        list.add(new HashMap<>(current)); // add to result.
    } else {
        K currentKey = map.keySet().stream().skip(index).findFirst().get(); // take the current key
        for (V value : map.get(currentKey)) {
            current.put(currentKey, value); // put each value into the temporary map
            combine(index + 1, current, map, list); // recursive call
            current.remove(currentKey); // discard and try next value
        }
    }
}