在 Java 中創建抽象數據類型

Question

我需要創建一個集合，它將保存兩個集合的交集。 如果這些集合之一中存在的值發生更改，則intersectionSet 也應受到影響。

設置測試：

Set<Integer> testSet1 = new HashSet<>();
testSet1.add(1);
testSet1.add(2);
testSet1.add(3);

Set<Integer> testSet2 = new HashSet<>();
testSet2.add(2);
testSet2.add(4);

如果我以這種方式實現intersectionSet，即使testSet1 或testSet2 被更改也不會受到影響。

Set<Integer> intersectionSet = new HashSet<>(testSet1);
intersectionSet.removeIf(element -> !testSet2.contains(element));

如果我以這種方式實現它，在創建intersectionSet 時，testSet1 或testSet2 將被.removeIf() 修改，但這里只是從intersectionSet 中刪除對該值的引用。

Set<Integer> intersectionSet;
intersectionSet = testSet1;
intersectionSet.removeIf(element -> !testSet2.contains(element));

通常，intersectionSet 應該只引用 testSet1 和 testSet2 中適合條件的值。

問題是，我如何實現intersectionSet，它依賴於testSet1 和testSet2（以及它們的內容）並且不會改變它們。

我需要這樣的東西：

System.out.println(testSet1.contains(1)); // print true

IntersectionSet intersectionSet = new IntersectionSet(testSet1, testSet2);

System.out.println(testSet1.contains(1)); // print true
System.out.println(testSet2.contains(4)); // print true
System.out.println(intersectionSet.contains(2)); // print true

testSet1.remove(2);

System.out.println(intersectionSet.contains(2)); // print false

我的代碼如下：

interface OMOSetView {
    boolean contains(int element); // test if element is in set

    int[] toArray(); //return copy of elemets from set in array

    OMOSetView copy(); //return copy of set

    int size(); //return size of set

    HashSet<Integer> getSet(); //retunrn set
}

// class which represents common set, defines methods add/remove
class OMOSet implements OMOSetView {
    private HashSet<Integer> omoSet = new HashSet<>();

    public void add(int element) {
        if (!omoSet.contains(element)) {
            omoSet.add(element);
        }
    }

    public void remove(int element) {
        if (omoSet.contains(element)) {
            omoSet.remove(element);
        }
    }

    public boolean contains(int element) {
        return omoSet.contains(element);
    }

    public int[] toArray() {
        int[] array = new int[omoSet.size()];
        int i = 0;
        for (Integer element : omoSet) {
            array[i] = element;
            i++;
        }
        return array;
    }

    public OMOSet copy() {
        OMOSet copySet = new OMOSet();
        for (Integer element : omoSet) {
            copySet.add(element);
        }
        return copySet;
    }

    public int size() {
        return omoSet.size();
    }

    public HashSet<Integer> getSet() {
        return this.omoSet;
    }

}

    // class represents intersectionSet of two sets A and B
class OMOSetIntersection implements OMOSetView {
    private HashSet<Integer> intersectionSet;

    OMOSetIntersection(OMOSetView setA, OMOSetView setB) {
        intersectionSet = setA.getSet();                              // it's not working
        intersectionSet.removeIf(element -> !setB.contains(element)); // it's not working
    }

    public boolean contains(int element) {
        return intersectionSet.contains(element);
    }

    public int[] toArray() {
        int[] array = new int[intersectionSet.size()];
        int i = 0;
        for (Integer element : intersectionSet) {
            array[i] = element;
            i++;
        }
        return array;
    }

    public OMOSet copy() {
        OMOSet copySet = new OMOSet();
        for (Integer element : intersectionSet) {
            copySet.add(element);
        }
        return copySet;
    }

    public int size() {
        return intersectionSet.size();
    }

    public HashSet<Integer> getSet() {
        return intersectionSet;
    }
}

Answer 1

您應該使用實現延遲計算的包裝器：這意味着它們不保存實際的交集元素，而是保留對原始集合的引用並根據請求提供交集。

Google Guava 提供了大量延遲計算的收集實用程序。 在您的情況下com.google.common.collect.Sets#intersection(Set<E> set1, Set<?> set2)是一種方法：

Set<Integer> testSet1 = new HashSet<>();
testSet1.add(1);
testSet1.add(2);
testSet1.add(3);

Set<Integer> testSet2 = new HashSet<>();
testSet2.add(2);
testSet2.add(4);

Set<Integer> intersectionSet = Sets.intersection(testSet1, testSet2);