是否存在可以由任何成员处理集合的集合集？

Question

我试图在Java（或Groovy）中找到一个这样的数据结构：

MemberAdressableSetsSet mass = new MemberAdressableSetsSet();
mass.addSet(["a","b"]);
mass.addSet(["c","d","e"]);
mass.get("d").add("f");
String output = Arrays.toString(mass.get("e").toArray());
System.out.println(output); // [ "c", "d", "e", "f" ] (ordering irrelevant)

这样的事情存在吗？ 如果没有，有没有办法用普通的Java代码实现这样的东西，这些代码几周内不会给CPU或内存带来噩梦？

编辑：更严格

MemberAdressableSetsSet mass = new MemberAdressableSetsSet();
Set<String> s1 = new HashSet<String>();
s1.add("a");
Set<String> s2 = new HashSet<String>();
s2.add("c");s2.add("d");s2.add("e");
mass.addSet(s1);
mass.addSet(s2);
Set<String> s3 = new HashSet<String>();
s3.add("a");s3.add("z");

mass.addSet(s3);
/* s3 contains "a", which is already in a subset of mass, so:
 * Either
 *   - does nothing and returns false or throws Exception
 *   - deletes "a" from its previous subset before adding s3
 *      => possibly returns the old subset
 *      => deletes the old subset if that leaves it empty
 *      => maybe requires an optional parameter to be set
 *   - removes "a" from the new subset before adding it
 *      => possibly returns the new subset that was actually added
 *      => does not add the new subset if purging it of overlap leaves it empty
 *      => maybe requires an optional parameter to be set
 *   - merges all sets that would end up overlapping
 *   - adds it with no overlap checks, but get("a") returns an array of all sets containing it
 */

mass.get("d").add("f");
String output = Arrays.toString(mass.get("e").toArray());
System.out.println(output); // [ "c", "d", "e", "f" ] (ordering irrelevant)

mass.get("d")将返回包含"d" mass Set<T> 。 类似于get（）在HashMap工作原理：

HashMap<String,LinkedList<Integer>> map = new HashMap<>();
LinkedList<Integer> list = new LinkedList<>();
list.add(9);
map.put("d",list);
map.get("d").add(4);
map.get("d"); // returns a LinkedList with contents [9,4]

Answer 1

到目前为止，我能想出的最好看起来像这样：

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

public class MemberAdressableSetsSet {
    private int next_id = 1;
    private HashMap<Object,Integer> members = new HashMap();
    private HashMap<Integer,Set> sets = new HashMap();
    public boolean addSet(Set s) {
        if (s.size()==0) return false;
        for (Object member : s) {
            if (members.get(member)!=null) return false;
        }
        sets.put(next_id,s);
        for (Object member : s) {
            members.put(member,next_id);
        }
        next_id++;
        return true;
    }
    public boolean deleteSet(Object member) {
        Integer id = members.get(member);
        if (id==null) return false;
        Set set = sets.get(id);
        for (Object m : set) {
            members.remove(m);
        }
        sets.remove(id);
        return true;
    }
    public boolean addToSet(Object member, Object addition) {
        Integer id = members.get(member);
        if (id==null) throw new IndexOutOfBoundsException();
        if (members.get(addition)!=null) return false;
        sets.get(id).add(addition);
        members.put(addition,id);
        return true;
    }
    public boolean removeFromSet(Object member) {
        Integer id = members.get(member);
        if (id==null) return false;
        Set s = sets.get(id);
        if (s.size()==1) sets.remove(id);
        else s.remove(member);
        members.remove(member);
        return true;
    }
    public Set getSetClone(Object member) {
        Integer id = members.get(member);
        if (id==null) throw new IndexOutOfBoundsException();
        Set copy = new java.util.HashSet(sets.get(id));
        return copy;
    }
}

这有一些缺点：

• 集合不能直接访问，这使得未通过显式定义的转换方法公开的所有Set方法和属性都不可访问，除非克隆是可接受的选项
• 类型信息丢失。
  • 假设添加了Set<Date> 。
    它不会抱怨尝试将File对象添加到该集合。

至少集合的丢失类型信息不会扩展到它们的成员： Set.contains()仍然完全按预期工作，尽管在被contains()比较之前，双方都被强制转换为Object 。 因此，当被问及是否包含(Object)3L ，包含(Object)3的集合将不会返回true，反之亦然。

包含(Object)(new java.util.Date(10L))的集合在被询问是否包含(Object)(new java.sql.Date(10L))时会返回true (Object)(new java.sql.Date(10L)) ），但这是真的即使没有(Object)在前面，所以我猜这是“按预期工作”¯\\ _（ツ）_ /¯

Answer 2

您需要多久访问一个元素？ 可能值得使用地图并在多个键下存储相同的Set参考。

我会阻止对地图和子集的外部变异，并提供帮助方法来完成所有更新：

public class MemberAdressableSets<T> {
    Map<T, Set<T>> data = new HashMap<>();

    public void addSet(Set<T> dataSet) {
        if (dataSet.stream().anyMatch(data::containsKey)) {
            throw Exception("Key already in member addressable data");
        }
        Set<T> protectedSet = new HashSet<>(dataSet);
        dataSet.forEach(d -> data.put(d, protectedSet));
    }

    public void updateSet(T key, T... newData) {
        Set<T> dataSet = data.get(key);
        Arrays.stream(newData).forEach(dataSet::add);
        Arrays.stream(newData).forEach(d -> data.put(d, dataSet));
    }

    public Set<T> get(T key) {
        return Collections.unmodifiableSet(data.get(key));
    }
}

或者，如果密钥不存在，则可以更新addSet和updateSet以创建新的Set实例，并使updateSet永不throw 。 您还需要扩展此类以处理合并集的情况。 即处理用例：

mass.addSet(["a","b"]);
mass.addSet(["a","c"]);

Answer 3

这个解决方案允许像mass.get("d").add("f");这样的东西mass.get("d").add("f"); 影响存储在mass的子集，但有很大的缺点。

import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;

public class MemberAdressableSetsSetDirect {
    private LinkedHashSet<Set> sets;
    public void addSet(Set newSet) {
        sets.add(newSet);
    }
    public Set removeSet(Object member) {
        Iterator<Set> it = sets.iterator();
        while (it.hasNext()) {
            Set s = it.next();
            if (s.contains(member)) {
                it.remove();
                return s;
            }
        }
        return null;
    }
    public int removeSets(Object member) {
        int removed = 0;
        Iterator<Set> it = sets.iterator();
        while (it.hasNext()) {
            Set s = it.next();
            if (s.contains(member)) {
                it.remove();
                removed++;
            }
        }
        return removed;
    }
    public void deleteEmptySets() {
        sets.removeIf(Set::isEmpty);
    }
    public Set get(Object member) {
        for (Set s : sets) {
            if (s.contains(member)) return s;
        }
        return null;
    }
    public Set[] getAll(Object member) {
        LinkedHashSet<Set> results = new LinkedHashSet<>();
        for (Set s : sets) {
            if (s.contains(member)) results.add(s);
        }
        return (Set[]) results.toArray();
    }
}

没有针对重叠的内置保护，因此我们具有不可靠的访问，并且引入了无数空集的可能性，需要通过手动调用deleteEmptySets()来定期清除，因为此解决方案无法检测是否有子集被直接访问修改。

MemberAdressableSetsSetDirect massd = new MemberAdressableSetsSetDirect();
Set s1 = new HashSet();Set s2 = new HashSet();Set s3 = new HashSet();
s1.add("a");s1.add("b");
s2.add("c");s2.add("d");
s3.add("e");
massd.addSet(s1);massd.addSet(s2);
massd.get("c").add("a");
// massd.get("a") will now either return the Set ["a","b"] or the Set ["a","c","d"]
// (could be that my usage of a LinkedHashSet as the basis of massd
//  at least makes it consistently return the set added first)
massd.get("e").remove("e");
// the third set is now empty, can't be accessed anymore,
// and massd has no clue about that until it's told to look for empty sets
massd.get("c").remove("d");
massd.get("c").remove("c");
// if LinkedHashSet makes this solution act as I suspected above,
// this makes the third subset inaccessible except via massd.getAll("a")[1]

此外，该解决方案也无法保留类型信息。
这甚至不会发出警告：

MemberAdressableSetsSetDirect massd = new MemberAdressableSetsSetDirect();
Set<Long> s = new HashSet<Long>();
s.add(3L);
massd.addSet(s);
massd.get(3L).add("someString");
// massd.get(3L) will now return a Set with contents [3L, "someString"]