精华内容
下载资源
问答
  • Java判断两个集合是否有交集

    千次阅读 2020-11-18 11:33:17
    判断两个集合之间是否有交集,比如场景:前端传了list集合,后端字段里存的也是(1,2,3,4)这种形式。不借助sql,怎么看前端传的集合是否在后端字段的集合中? 2.代码 public static boolean judgeIntersection(List...

    1.问题

    判断两个集合之间是否有交集,比如场景:前端传了list集合,后端字段里存的也是(1,2,3,4)这种形式。不借助sql,怎么看前端传的集合是否在后端字段的集合中?

    2.代码

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

    3.boolean flag = origin.retainAll(Collection<?> c)

    若origin中有集合C中没有的数据,返回false。没有返回true

    同时,origin集合会改变,只保留两个集合相同的数据,换句话说,origin集合有被删除的数据,返回false

    那如何判断是否有交集?

    ① 两个集合,一个一样的都没有,origin为空,返回值是false

    ② 两个集合,碰巧,origin中的数据都在c中,origin不变,返回值是true

    这两种特殊情况都是导致单纯靠返回值true or false,是不能判断有交集的。所以根据要origin集合中的个数,>0,就是有交集

    4.retainAll(Collection<?> c)源码

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

    本博客是日常积累的知识,现准备逐步从云笔记移到这里,所以,有的文章可能是当时查资料及看书,再加上自己的理解得出的结论。现已找不到当时参考的文章,没办法贴出参考链接。如有冒犯,请告知,将及时贴出原文链接。

    展开全文
  • Java如何判断两个集合的元素是否完全相等

    万次阅读 多人点赞 2019-01-09 15:11:13
    Java如何判断两个集合的元素是否完全相等 &nbsp;&nbsp;&nbsp;&nbsp;博主最近在工作的时候遇到了这样的一个需求,前端的页面提交一个表单数据,传到后台,我需要做判断这个表单和已有的表单数据是否...

    Java如何判断两个集合的元素是否完全相等


        博主最近在工作的时候遇到了这样的一个需求,前端的页面提交一个表单数据,传到后台,我需要做判断这个表单和已有的表单数据是否有完全相同的,如果有相同的数据,那么就返回一个false,这一个表单不能被保存,如果不同,就可以保存到数据库中。

    一,实现

    1. 最简单粗暴的方法,遍历循环

    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent(list, list1));
        }
        
        /**
         * 方法一:使用循环遍历
         */
         private static boolean checkDiffrent(List<String> list, List<String> list1) {
            long st = System.nanoTime();
            if(list.size() != list1.size()) {
                System.out.println("消耗时间:" + (System.nanoTime() - st));
                return false;
            }
            for(String str : list) {
                if(!list1.contains(str)) {
                    System.out.println("消耗时间:" + (System.nanoTime() - st));
                    return false;
                }
            }
            System.out.println("消耗时间:" + (System.nanoTime() - st));
            return true;
         }
     }
    
    

    返回结果为:

    消耗时间为: 16657988
    false

    这是我想到的第一种方法,耗时较长,代码也不够简洁!

    2. 使用List的retainAll方法进行比较

    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent1(list, list1));
        }
        
        /**
         * 方法2:利用List的 retainAll的方法进行判断
         */
        private static boolean checkDiffrent1(List<String> list, List<String> list1) {
            long st = System.nanoTime();
            System.out.println("消耗时间为:" + (System.nanoTime() - st));
            return !list.retainAll(list1);
        }
        
    }
    

    返回结果为:

    消耗时间为:7711
    false

    但是这个retainAll这个方法有缺陷,如果集合A数组的大小没有改变,则返回false。如果集合A和集合B是完全相同的集合,也会返回false。两个集合没有交集,才会返回true。简单来说,判断两个集合是否有交集,有则返回false,无则返回true(这句话不严谨)。总结来说只有两个任何一个元素都不相等时才会返回true,否则返回false。那这个结果不是我想要的。

    3. 利用HashMap的唯一性,把元素当做key,value可以重复。把list存到HashMap中

        我们的需求是判断两个List中的元素是否相同,那么可以这样考虑:用一个map存放list的所有元素,其中的key为list1的各个元素,value为该元素出现的次数,接着把list2的所有元素也放到map里,如果已经存在则value+1,一旦value停止+1,说明有元素不同了,返回false。否则一直遍历直至list2中所有元素,返回true。这样我们只需循环m+n次,大大减少了循环的次数。

    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent1(list, list1));
        }
        
         /** 
          * 方法3 
          * 利用HashMap key唯一,value可以重复的特点,把list中各种元素放到hashMap中 
          */
          private static boolean checkDiffrent2(List<String> list, List<String> list1) {
            long st = System.nanoTime();
            Map<String, Integer> map = new HashMap<>(list.size() + list1.size());
            if (list.size() != list1.size()) {    
                System.out.println("消耗时间为: " + (System.nanoTime() - st));    
                return false;
            }
            for (String str : list) {    
                map.put(str, 1);
            }
            for (String str : list1) {    
                Integer cc = map.get(str);    
                if (null != cc) {        
                    continue;    
                }    
                System.out.println("消耗时间为: " + (System.nanoTime() - st));    
                return false;
            }
            System.out.println("消耗时间为: " + (System.nanoTime() - st));
            return true;
          }
    }
    

    结果:

    消耗时间为: 4243019
    false

    此方法使用了HashMap中key必须唯一,但是value可以重复的原因。但是HashMap是不同步的,所以线程不安全。

    4. 利用MD5加密法来判断两个集合是否相等

    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent1(list, list1));
        }
        
         /** 
          * md5加密法使用 
          * 方法4 
          */
         private static boolean getDiffrent3(List<String> list, List<String> list1) {    
            long st = System.nanoTime();  
            /** 使用Security的md5方法进行加密 */
            String str = SecureUtil.md5(list.toString());     
            String str1 = SecureUtil.md5(list1.toString());
            System.out.println("消耗时间为: " + (System.nanoTime() - st)); 
            return str.equals(str1);
        }
    }
    

    结果:

    消耗时间为: 88603223
    false

    这个方法很新奇吧,是我没有想到的,最好不要用这种方法,如果你在实际项目中使用这种方法,被打死了,请不要找我emmm~

    5. 使用Java8的新特性steam流去比较两个数组是否相等
    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent4(list, list1));
        }
        
         /** 
          * 使用stream流去比较两个数组是否相等
          * 方法5
          */
         private static boolean checkDiffrent4(List<String> list, List<String> list1) {    
            long st = System.nanoTime();  
            System.out.println("消耗时间为: " + (System.nanoTime() - st)); 
            /** 先将集合转成stream流进行排序然后转成字符串进行比较 */
            return list.stream().sorted().collect(Collectors.joining())
                            .equals(list1.stream().sorted().collect(Collectors.joining()));
           }
    }
    

    结果:

    99273484
    false

    利用了Java8的新特性然后用collect(Collectors.joining())进行比较,虽然比较耗时,但是很好用是真的。

    6. 使用list转成字符串进行比较是否相等

    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent4(list, list1));
        }
        
         /** 
          * 使用list自带的sort方法先进性排序,然后转成toString去判断两个集合是否相等
          * 方法6
          */
         private static boolean checkDiffrent5(List<String> list, List<String> list1) { 
            long st = System.nanoTime();
            System.out.println("消耗时间为: " + (System.nanoTime() - st)); 
            list.sort(Comparator.comparing(String::hashCode));  
            list1.sort(Comparator.comparing(String::hashCode)); 
            return list.toString().equals(list1.toString());
        }
    }
    

    结果:

    2570
    false

    个人感觉先将集合转成字符串,然后进行equal(),进行判断是一个比较优秀的方法, 比起用循环编辑要简洁很多。

    二,总结

        上面的六种方法的耗时时间依次是checkDiffrent5 < checkDiffrent1 < checkDiffrent2 < checkDiffrent < checkDiffrent3 < checkDiffrent4。所以最好的方法是使用list.sort()方法来进行排序,在用toString进行equal比较。
    Security源代码地址:Security地址

    附下我写的所有代码:

    package list.demo;
    
    import java.io.Serializable;
    import java.util.*;
    import java.util.stream.Collectors;
    
    /**
     * 判断两个集合是否相等
     */
     public class CheckDiffList implements Serializable {
        public static void main(String[] args) {    
            List<String> list = new ArrayList<>();    
            List<String> list1 = new ArrayList<>();    
            for (int i = 0; i < 1000; i++) {        
                list.add("test" + i);        
                list1.add("test" + (i * 2));    
            }    
            System.out.println(checkDiffrent(list, list1));
        }
        
        /**
         * 方法一:使用循环遍历
         */
         private static boolean checkDiffrent(List<String> list, List<String> list1) {
            long st = System.nanoTime();
            if(list.size() != list1.size()) {
                System.out.println("消耗时间:" + (System.nanoTime() - st));
                return false;
            }
            for(String str : list) {
                if(!list1.contains(str)) {
                    System.out.println("消耗时间:" + (System.nanoTime() - st));
                    return false;
                }
            }
            System.out.println("消耗时间:" + (System.nanoTime() - st));
            return true;
         }
         
          /**
         * 方法2:利用List的 retainAll的方法进行判断
         */
        private static boolean checkDiffrent1(List<String> list, List<String> list1) {
            long st = System.nanoTime();
            System.out.println("消耗时间为:" + (System.nanoTime() - st));
            return !list.retainAll(list1);
        }
        
        /** 
          * 方法3 
          * 利用HashMap key唯一,value可以重复的特点,把list中各种元素放到hashMap中 
          */
          private static boolean checkDiffrent2(List<String> list, List<String> list1) {
            long st = System.nanoTime();
            Map<String, Integer> map = new HashMap<>(list.size() + list1.size());
            if (list.size() != list1.size()) {    
                System.out.println("消耗时间为: " + (System.nanoTime() - st));    
                return false;
            }
            for (String str : list) {    
                map.put(str, 1);
            }
            for (String str : list1) {    
                Integer cc = map.get(str);    
                if (null != cc) {        
                    continue;    
                }    
                System.out.println("消耗时间为: " + (System.nanoTime() - st));    
                return false;
            }
            System.out.println("消耗时间为: " + (System.nanoTime() - st));
            return true;
          }
          
           /** 
          * md5加密法使用 
          * 方法4 
          */
         private static boolean getDiffrent3(List<String> list, List<String> list1) {    
            long st = System.nanoTime();  
            /** 使用Security的md5方法进行加密 */
            String str = SecureUtil.md5(list.toString());     
            String str1 = SecureUtil.md5(list1.toString());
            System.out.println("消耗时间为: " + (System.nanoTime() - st)); 
            return str.equals(str1);
        }
        
        /** 
          * 使用stream流去比较两个数组是否相等
          * 方法5
          */
         private static boolean checkDiffrent4(List<String> list, List<String> list1) {    
            long st = System.nanoTime();  
            System.out.println("消耗时间为: " + (System.nanoTime() - st)); 
            /** 先将集合转成stream流进行排序然后转成字符串进行比较 */
            return list.stream().sorted().collect(Collectors.joining())
                            .equals(list1.stream().sorted().collect(Collectors.joining()));
           }
           
           /** 
          * 使用list自带的sort方法先进性排序,然后转成toString去判断两个集合是否相等
          * 方法6
          */
         private static boolean checkDiffrent5(List<String> list, List<String> list1) { 
            long st = System.nanoTime();
            System.out.println("消耗时间为: " + (System.nanoTime() - st)); 
            list.sort(Comparator.comparing(String::hashCode));  
            list1.sort(Comparator.comparing(String::hashCode)); 
            return list.toString().equals(list1.toString());
        }
     }
    
    展开全文
  • 有这样的两个集合:   string[] bigArr = new string[] { "a", "b", "c" };string[] smallArr = new string[] { "a", "b"};   现在需要判断smallArr是否是...

    有这样的两个集合:

     

    string[] bigArr = new string[] { "a", "b", "c" };
    string[] smallArr = new string[] { "a", "b"};

     

    现在需要判断smallArr是否是bigArr的子集。只要拿着bigArray和smallArr比较,求差集,如果差集的个数大于0,就说明smallArr是bigArr的子集。

     

                //在大集合的基础上,根据小集合获取大集合的差集
                var exceptArr = bigArr.Except(smallArr);
    
                //判断是否是子集
                if(exceptArr.Any())
                {
                    Console.WriteLine("samllArr 是 bigArr的一个子集");
                }
                else
                {
                    Console.WriteLine("samllArr 不是 bigArr的一个子集");
                }

     

    以上的方式,只能判断是否是子集,即是子集的那个集合元素永远小于大的那个集合。

     

    有时候,还存在这样的需求:判断bigArr是否包含smallArr,即smallArr可以是bigArr的子集,也可以和bigArr是一样的。

     

                //判断是否是子集或2个集合一样
                if(smallArr.All(t => bigArr.Any(b => b==t)))
                {
                    Console.WriteLine("samllArr 是 bigArr的一个子集或一样");
                }
                else
                {
                    Console.WriteLine("samllArr 不是 bigArr的一个子集或一样");
                }

     

    展开全文
  • 判断一个元素是否在集合中 求两个集合的并集 求两个集合的差集 求两个集合的交集 在此基础上设计集合的顺序存储结构,并实现各基本算法 ADT ASet { 数据对象:D={di | 0<=i<=n;n为一个正整...

    描述一个集合的抽象数据类型为ASet,其中所有的元素都为正整数
    基本的运算为:
      由整数数组a[0..n-1]创建一个数组
      输出一个集合的所有元素
      判断一个元素是否在集合中
      求两个集合的并集
      求两个集合的差集
      求两个集合的交集

    在此基础上设计集合的顺序存储结构,并实现各基本算法

    ADT ASet
    
    {
    
    数据对象:D={di | 0<=i<=n;n为一个正整数}
    
    数据关系:无
    
    基本运算:
    
    CreateSet(&S,a,n);//创建一个集合S
    DispSet(S);//输出集合S中的所有元素
    InSet(S,e);//判断e是否在S中,如果在,则返回true,否则返回false
    Add(s1,s2,s3);//求两个集合的并集
    Sub(s1,s2,s4);//求两个集合的差集
    InterSection(s1,s2,s5);//求两个集合的交集
    
    }

    设计集合的顺序存储结构类型如下:

    typedef struct
    {
    	int data[MAXSIZE];
    	int length;        //定义的集合的长度
    }Set;                  //集合的别名为Set
    

    源代码为:

    #include<stdio.h>
    void CreateSet();
    void DispSet();
    bool InSet();
    void Add();
    void Sub();
    void InterSection();
    typedef struct
    {
    	int data[100];
    	int length;        //定义的集合的长度
    }Set;                  //集合的别名为Set
    
    void CreateSet(Set &s,int a[],int n)//创建一个集合
    {
    	int i;
    	for(i=0;i<n;i++)                 //遍历a[]中的数据插入到data[]中
    	{
    		s.data[i]=a[i];
    	}
    
    	s.length=n;						 //长度等于n
    }
    
    
    void DispSet(Set s)                  //打印这个集合
    {
    	int i;
    	for(i=0;i<s.length;i++)          //i<这个表的长度时,遍历这个表,一次打印
    	{
    		printf("%d",s.data[i]);
    	}
    	printf("\n");                    //最后一行换行
    }
    
    bool InSet(Set s,int e)              //判断一个元素在不在这个集合中,如果在,则返回true,否则返回false
    {
    	int i;
    	for(i=0;i<s.length;i++)
    	{
    		if(s.data[i]==e)
    			return true;
    	}
    	return false;
    }
    
    void Add(Set s1,Set s2,Set &s3)     //求集合的并集
    {
    	int i;
    	for (i=0;i<s1.length;i++)       //将集合s1中的元素全部复制到s3中去
    	{
    		s3.data[i]=s1.data[i];
    	}
    	s3.length=s1.length;
    	for (i=0;i<s2.length;i++)        //将s2中不在s1中的元素复制到s3中去
    	{
    		if(!InSet(s1,s2.data[i]))
    		{
    			s3.data[s3.length]=s2.data[i];
    			s3.length++;
    		}
    	}	
    }
    
    void Sub(Set s1,Set s2,Set &s4)     //求集合的差集
    {
    	int i;
    	s4.length=0;
    	for(i=0;i<s1.length;i++)        //将s1中不在s2中的元素复制到s4中去
    	{
    		if(!InSet(s2,s1.data[i]))
    		{
    			s4.data[s4.length]=s1.data[i];
    			s4.length++;
    		}
    	}
    
    }
    
    
    void InterSection(Set s1,Set s2,Set &s5)  //求两个集合的交集
    {
    	int i;
    	s5.length=0;
    	for(i=0;i<s1.length;i++)        //将s1中不在s2中的元素复制到s4中去
    	{
    		if(InSet(s2,s1.data[i]))
    		{
    			s5.data[s5.length]=s1.data[i];
    			s5.length++;
    		}
    	}
    }
    void main()
    {
    	Set s1,s2,s3,s4,s5;
    	int a[]={1,2,3,4,5};
    	int b[]={2,3,4,5,6,7,8};
    	int n=5,m=7;
    	CreateSet(s1,a,n);
    	CreateSet(s2,b,m);
    	printf("s1:");DispSet(s1);
    	printf("s2:");DispSet(s2);
    	printf("s1和s2的并集为:");
    	Add(s1,s2,s3);                //s1,s2,s3的并集s3
    	DispSet(s3);                  //打印并集s3
    	printf("s1和s2的差集s4为");
    	Sub(s1,s2,s4);
    	DispSet(s4); 
    	printf("s1和s2的差集s4为");
    	InterSection(s1,s2,s5);
    	DispSet(s5); 
    	return ;
    }
    
    

    展开全文
  • 判断一个元素在集合中很容易,只需要遍历这个集合,然后与每个值进行比较,如果有相等的,那么就存在在集合中,然后反过来,就是不存在集合中的,找到它好像挺容易,但是写起代码来好像有点绕,那么,现在就把它写...
  • 编写程序实现两个集 合的并、交,相对补,对称差,幂集的运算并判断两个集合是否相等
  • 比如这样一个需求,现有一个Teacher对象集合和一个Student对象集合,需要查出两个集合中姓名相同的记录该怎么办呢,通常我们想到的肯定是用双层for循环来做,如果用java8新特性lambda表达式怎么做呢?废话不多说,...
  • * 有两个集合A和B,判断两个集合是否包含相同的元素, * 可以使用retainAll方法:A.retainAll(B)。 * 如果存在相同元素,A中仅保留相同的元素。 * 如果不存在相同元素,A会变为空。 */ public class ListTest...
  • 离散题目3 ... DaYu在新的学习开始学习新的数学知识,一天DaYu学习集合的时候遇到一个问题,他有两个集合A和B,他想知道A是不是B的子集。 Input 多组输入,每组的第一行有两个数n,m,0 ,m ^5。表示集合
  • mybatis中判断两个集合是否为空

    万次阅读 2017-10-16 21:12:24
    在工作中遇到mybatis中判断两个集合是否为空,不为空的话遍历;都为空执行 1=0 or 1=0,则查询出来空集合 select login,name,email from users u where test="sameEmailList != null and sameEmailList.size > ...
  • 两个集合newCoures和oldCourses,判断两个集合是否包含相同的对象或元素, 可以使用retainAll方法:oldCourses.retainAll(newCoures)。 如果存在相同元素,oldCourses中仅保留相同的元素。 如果不存在相同...
  • //判断两个集合是否相交,是否有交集 import Search.QuickSort; public class Disjoint_Set extends QuickSort { public int Disjoint_Set(int a[], int b[]) { int count = 0; int i = 0, j = 0; Quicksort(a, 0...
  • 编写程序实现两个集 合的并、交,相对补,对称差的运算并判断两个集合是否相等? 功能要求 ①输入集合A与集合B的元素。 ②输出集合A与B的并、交、相对补、差、对称差运算。 ③输出集合A与B是否相等的断定结果。 ...
  • 在开发中,有时会碰到这样的需求,取两个集合的并集,也就是说如果其中个集合中的元素是[1,2,3,4,5],另个集合中的元素是[4,5,6,7,8],那么取这两个集合的并集得到的结果就是[1,2,3,4,5,6,7,8]。 合并两个集合...
  • a = [1,2,3,4] b = set([1,2]) b.issubset(a)
  • // 找出不同元素 private boolean getDiffrent(ArrayList list1, ArrayList list2) { long st = System.nanoTime(); Map map = new HashMap(list1.size() + list2.size());...ArrayList diff = new ArrayList();...
  • 判断两个集合的元素是否相同 1)基本数据类型 public static void main(String[] args) { List&lt;Integer&gt; list1=new ArrayList&lt;Integer&gt;(); list1.add(1); list1.add(2); list1....
  • java8 判断两个List集合交集 差集

    千次阅读 2019-10-22 14:10:24
    public static void main(String[] args) { List<String> list1 = new ArrayList(); list1.add("1"); list1.add("2"); list1.add("3"); list1.add("5");... List<String> list2 = new ...同时适用于对象实体类集合
  • 1.对于验证是否存在list集合中 List&lt;String&gt; apiIdString = new ArrayList&lt;String&gt;(); ... List&lt;String&gt; apiId = request.get**(); for (Strin...
  • 找出两个List集合重复的元素

    万次阅读 热门讨论 2019-02-13 20:26:56
    前几天,有个同事问我说怎么找出两个List集合中重复的元素,我当时就说一个集合在外面循环,一个集合在内循环,如果两个元素相等了,就找出来了,我回来想还是不对,要是数据非常多,这样循环下去,服务器会卡死的...
  • 一个map集合分为两个

    2020-09-13 20:50:20
    请问,现有一个map集合 key为月份,请问如何根据月份的奇偶将这个map集合分成两个map集合???请问各位大佬该怎么处理?,思考了好长时间解决不了
  • 两个list实体的数据....我该怎么去判断两个LIST集合的数据是否一样? 下面这个方法不行 if (ListA.Contains(ListB)) { MessageBox.Show("相等"); } else { MessageBox.Show("不想等"); }

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,685,673
精华内容 674,269
关键字:

如何判断两个集合是一个集合