So ermitteln Sie, ob es in Java eine Schnittmenge zwischen zwei Sammlungen gibt

Hintergrund:

Das Front-End übergibt die Listensammlung, und die Back-End-Felder haben ebenfalls die Form (1,2,3,4). Wie können Sie ohne Verwendung von SQL überprüfen, ob sich der vom Front-End übergebene Satz im Satz der Back-End-Felder befindet?

(Teilen von Lernvideos: Java-Lehrvideo)

Code:

public static boolean judgeIntersection(List<String> list1,List<String> list2){
    boolean flag = false;
    // 使用retainAll会改变list1的值，所以写一个替代
    List<String> origin = new ArrayList<>();
    origin.addAll(list1);
    origin.retainAll(list2);
    // 有交集
    if(origin.size()>0){
        flag = true;
    }
    return flag;
}

boolean flag = origin.retainAll(Collection c)

Wenn es Daten im Ursprung gibt, die nicht in Sammlung C sind , gebe false zurück. Es wird kein „true“ zurückgegeben

Gleichzeitig ändert sich der Ursprungssatz und nur die gleichen Daten der beiden Sätze werden beibehalten. Mit anderen Worten, der Ursprungssatz hat gelöschte Daten und es wird „false“ zurückgegeben

Wie kann man also feststellen? ob es eine Kreuzung gibt?

1. Zwei Sätze, keiner von ihnen ist gleich, der Ursprung ist leer und der Rückgabewert ist falsch.

2. Zwei Sätze, die Daten im Ursprung sind zufällig alle in c, der Ursprung bleibt unverändert und der Rückgabewert Wert ist wahr

Diese beiden Sondersituationen führen dazu, dass es unmöglich ist, die Schnittmenge einfach anhand des Rückgabewerts wahr oder falsch zu beurteilen. Entsprechend der Anzahl der Ursprungssammlungen >0 gibt es also einen Schnittpunkt

retainAll(Collection c) Quellcode

public boolean retainAll(Collection<?> c) {
        // 判断c集合是否为空
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }
 
    private boolean batchRemove(Collection<?> c, boolean complement) {
        // 得到调用该函数的集合。因为是引用类型，所以修改了都会有变化
        final Object[] elementData = this.elementData;
        // w:记录交集的数据都放到elementData前面，w是其位置分界线
        int r = 0, w = 0;
        // 返回值 用于判断elementData有没有被修改
        boolean modified = false;
        try {
            // 循环elementData集合，判断其中元素是否在c集合中
            for (; r < size; r++)
                // 若在集合中，则w自增，并将该值放到elementData[w]中，即是交集的数据都放到集合的前面
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            // 正常情况下，经过上面的循环，r==size。为防止出现循环异常，将由于异常导致的r到size是交集的数据但并没有放到对应w的位置的数据，都放到对应w之后的位置上
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            // 若elementData中有数据不在c集合中，就清理掉w位置之后的数据，便于垃圾回收
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                // 记录elementData集合被增删的次数，这里是删除
                modCount += size - w;
                // 赋值最新的size
                size = w;
                // elementData集合被清理，modified为true
                modified = true;
            }
        }
        return modified;
    }

Verwandte Empfehlungen: Java-Einführungs-Tutorial

Das obige ist der detaillierte Inhalt vonSo ermitteln Sie, ob es in Java eine Schnittmenge zwischen zwei Sammlungen gibt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!