Comment déterminer s'il existe une intersection entre deux ensembles en Java

Contexte :

Le front-end a réussi la collection de listes et le champ back-end l'a stocké sous la forme de (1,2,3,4) . Sans utiliser SQL, comment vérifier si l'ensemble passé par le front-end est dans l'ensemble des champs back-end ?

(Partage de vidéos d'apprentissage : vidéo d'enseignement Java)

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

S'il y a des données dans origin qui ne sont pas dans l'ensemble C, renvoie false. Si true n'est pas renvoyé

, en même temps, l'ensemble d'origine changera, et seules les mêmes données des deux ensembles seront conservées. En d'autres termes, l'ensemble d'origine a des données supprimées, et false <. 🎜>

sera restitué Alors comment juger s'il y a Intersection ?

1. Deux ensembles, aucun d'eux n'est identique, origin est vide et la valeur de retour est fausse

2 Deux ensembles, par hasard, les données dans origin sont toutes en c. , origin Aucun changement, la valeur de retour est vraie

Ces deux cas particuliers conduisent au fait qu'il est impossible de juger de l'intersection simplement en se basant sur la valeur de retour vraie ou fausse. Par conséquent, selon le nombre de collections d'origine, >0, il existe une intersection

retainAll(Collection c) code source

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;
    }

Recommandations associées :

Tutoriel d'introduction à Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!