java-如何在循环中在Hashset中找到值的交集？

Question

I wrote a program in Java where it retrieves records from a database table and stored them in a hashmap.

The keys and values of them are like the following:

Key(represent words)      Values(represent filename)

w1                          file1
w2                          file1
w3                          file2
w4                          file1
w5                          file2
w6                          file1,file2
............

The list goes on and on but this is just an idea of how it looks like.As you can see, there's no duplicate for words and they are unique.

Given that I have this hashmap info,I need to find the intersection of the key and it's next key and return the results of the intersection. The idea looks like this:

w1∩w2= file1
w2∩w3= empty
w3∩w4= empty

........and it keeps going until it reaches the finishes the final pair of keys in the hashmap.

Since the pair of intersection results depends on the number of keys in the hashmap,I am guessing I'll need to use some loop to keep it iterating to return all the results.

Is there a way on how to get the intersection of each subsequent keys and also a way that is optimize regardless the size of the hashmap?

I appreciate any suggestion.

Answer 1

Make a variable that will hold all those intersections. In your loop retrieve 2 keys at a time. Compare each values of the 2 keys and if they are the same add the value to your intersection holder. Repeat the steps until there is no more pairs.

Here is the code.

Add this below your try/catch

LinkedHashmap<String, Set<String>> intersectionMap = new LinkedHashmap<>();
if (map.keySet() != null) {
    String[] keys = map.keySet().toArray(new String[map.keySet().size()]);
    for (int i = 0; i < keys.length - 1; i++) {
        String key1 = keys[i];
        String key2 = keys[i + 1];
        TreeSet<String> interSection = intersection(map.get(key1), map.get(key2));
        intersectionMap.put(key1 + "∩" + key2, interSection);
    }
}

Add this helper method. This method will find the intersection of the two sets. This will be the key in solving your problem.

public static TreeSet<String> intersection(TreeSet<String> setA, TreeSet<String> setB) {
    // An optimization to iterate over the smaller set
    if (setA.size() > setB.size()) {
        return intersection(setB, setA);
    }
    TreeSet<String> results = new TreeSet<>();
    for (String element : setA) {
        if (setB.contains(element)) {
            results.add(element);
        }
    }
    return results;
}

Answer 2

Yet another version with set operations:

Map<String>, Set<String>> intersections(Map<String, TreeSet<String>> map) {
    Map<String>, Set<String>> result = new TreeMap<>();

    List<String> words = new ArrayList<>(map.keySet());
    words.sort();
    for (int i = 0; i < words.size() - 1; ++i) {
        String wordI = words.get(i);
        Set<String> valueI = map.get(wordI);
        for (int j = i + 1, j < words.size(); ++j) {
            String wordJ = words.get(j);
            Set<String> valueJ = map.get(wordJ);

            String word = wordi + "∩" + words[j];
            Set<String> value = new TreeSet<>(valueI);
            value.retainAll(valueJ);
            result.put(word, value);
        }
    }
    return result;
}