精华内容
下载资源
问答
  • **你在调用contains()方法的时候, 或者是你在根据对象移除元素 remove(Object o) 你知道他们是如何判断集合中元素是否 是相等的吗**? 接下来我们跟着源码去详细探究一下 数据数据结构不同判断的依据就不同,我们...

    我们经常使用的集合如ArrayList,LinkedList,Vector,
    **你在调用contains()方法的时候, 或者是你在根据对象移除元素 remove(Object o) 你知道他们是如何判断集合中的元素是否
    是相等的吗**?
    接下来我们跟着源码去详细探究一下
    数据数据结构不同判断的依据就不同,我们先来看一下List类的判断依据.

    先简单的了解一下
    List类 : 有序,可以有重复元素。

    ArrayList 底层是一个对象数组
    private transient Object[] elementData;
    LinkedList 属于链式数据结构,底层用的是一个Node类的节点,包括指针域和数据域.

    private static class Node {
    E item;
    Node next;
    Node prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    

    ArrayList LinkedList他们都是线程不同步的 Vector非常类似ArrayList,但是Vector是同步的。, ArrayList LinkedList多线程访问会抛出 ConcurrentModificationException。如果想使他们线程同步的可以使用 Collections.synchronizedList 方法将该集合“包装”起来

    回归正题

    我们想知道他们如何判断集合元素是否相等,我们应该想到的是contains(Object o)方法,接下来我们看一下contains(Object o)方法

      public boolean contains(Object o) {
            return indexOf(o) >= 0;
        }
    

    他的方法内部调用了indexOf(o)这个方法,我们继续追踪看一下indexOf(o)方法

       public int indexOf(Object o) {
            if (o == null) {
                for (int i = 0; i < size; i++)
                    if (elementData[i]==null)
                        return i;
            } else {
                for (int i = 0; i < size; i++)
                    if (o.equals(elementData[i]))
                        return i;
            }
            return -1;
        }

    看到这里我们应该能明白了 先判断要查找的元素是否为空,不为空的话就调用equals方法.由此我们得到一个结论
    List类中判断元素是否相等依赖的是equals方法.

    set类 : 无序,不允许重复

    HashSet :
    此实现不是同步的
    我们知道HashSet它不允许出现重复元素,他是如何保证元素唯一的呢,我们应该首先想到的是看他的add()方法
    如下

    public boolean add(E e) {
    return map.put(e, PRESENT)==null;
    }

    这里出现了一个map我们找找看看他是什么

    我们在上面看到了他的定义

     private transient HashMap<E,Object> map;
    
    

    现在我们知道了HashSet的内部其实是一个HashMap来维护的,众所周知HashMap的键是不允许有相同的,不用说HashMap的键就是HashSet的值,接下来我们只需要知道HashMap的键是如何保证唯一的就行了

    我们就要追踪HashMap的添加元素方法 put(K key, V value)

    public V put(K key, V value) {
            if (table == EMPTY_TABLE) {
                inflateTable(threshold);
            }
            if (key == null)
                return putForNullKey(value);
            int hash = hash(key);
            int i = indexFor(hash, table.length);
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {
                Object k;
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }

    虽然有点麻烦我们只需要仔细看看 一定可以看明白 抓住最重要的一句

    e.hash == hash && ((k = e.key) == key || key.equals(k))

    现在我们也知道了HashSet 和HaspMap 保证元素唯一的办法是 先比较两个元素的哈希值,如果哈希值相等,在比较元素的地址是否相同,或者调用两个元素的equals方法如果哈希值不同,就根本不用在比较了.

    展开全文
  • 今天小编就为大家分享一篇关于Java判断2个List集合是否相等(不考虑元素的顺序)的文章,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • public class ListUtils { ... * 判断集合元素是否相等(无序) */ public static boolean isEqualCollection(Collection a, Collection b){ if (a.size() !=b.size()) { // size是最简单的相等条件 ...
    public class ListUtils {
    
        /**
         * 判断集合元素是否相等(无序)
         */
        public static boolean isEqualCollection(Collection a, Collection b){
    
            if (a.size() !=b.size()) {  // size是最简单的相等条件
                return false;
            }
            Map mapa = getCardinalityMap(a);
            Map mapb = getCardinalityMap(b);
    
            // 转换map后,能去掉重复的,这时候size就是非重复项,也是先决条件
            if (mapa.size() !=mapb.size()) {
                return false;
            }
            Iterator it =mapa.keySet().iterator();
            while (it.hasNext()) {
                Object obj = it.next();
                // 查询同一个obj,首先两边都要有,而且还要校验重复个数,就是map.value
                if (getFreq(obj,mapa) != getFreq(obj, mapb)) {
                    return false;
                }
            }
            return true;
        }
    
    
        public static Map getCardinalityMap(Collection coll) {
            Map count = new HashMap();
            Iterator it = coll.iterator();
            for (it.hasNext()) {
                Object obj =it.next();
                Integer c =(Integer) count.get(obj);
                if (c == null)
                    count.put(obj, 1);
                else {
                    count.put(obj, new Integer(c.intValue() + 1));
                }
            }
            return count;
        }
    
        private static final int getFreq(Object obj, Map freqMap) {
            Integer count =(Integer) freqMap.get(obj);
            if (count != null) {
                return count.intValue();
            }
            return 0;
        }
    
    }
    
    
    展开全文
  • 判断集合是否相等

    千次阅读 2020-09-02 20:46:06
    测试代码demo: import java.util.ArrayList;...那如果两个集合里的元素相等的,只是顺序不同呢,修改如下: 运行结果如下: 结果就变为false了。说明使用equals方法来比较集合是否相等,元素顺序也是评判的标准之一。

    测试代码demo:

    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    
    public class Test {
        public static void main(String[] args) {
            List<String> arrayList = new ArrayList<>();
            arrayList.add("a");
            arrayList.add("b");
            arrayList.add("c");
            List<String> linkList = new LinkedList<>();
            linkList.add("a");
            linkList.add("b");
            linkList.add("c");
            System.out.println(arrayList.equals(linkList));
        }
    }
    

    输出结果如下:
    在这里插入图片描述
    可以发现结果是相等的,符合预期。

    那么接着看看用于比较的equals方法,如下:

    public boolean equals(Object o) {
        //==比较引用地址,如果相等,说明是一个对象,返回true
        if (o == this)
            return true;
        //看下类型是否是List
        if (!(o instanceof List))
            return false;
         //通过迭代器来访问list的所有元素
        ListIterator<E> e1 = listIterator();
        ListIterator<?> e2 = ((List<?>) o).listIterator();
       //比较大小
        while (e1.hasNext() && e2.hasNext()) {
            E o1 = e1.next();
            Object o2 = e2.next();
            //只要不相等,就返回false
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        //比较长度是否相等
        return !(e1.hasNext() || e2.hasNext());
    }
    

    可以发现比较集合是否相等的逻辑就是顺序比较每一个元素是否相等以及长度是否相等。那如果两个集合里的元素相等的,只是顺序不同呢,修改如下:
    在这里插入图片描述
    运行结果如下:
    在这里插入图片描述
    结果就变为false了。说明使用equals方法来比较集合是否相等,元素顺序也是评判的标准之一。

    展开全文
  • 有两个集合A和B,判断这两个集合是否包含相同的对象或元素,可以使用retainAll方法:A.retainAll(B)。如果存在相同元素,A仅保留相同的元素。如果不存在相同元素,A会变为空。 总的来说:如果集合A和集合B是完全...

    第一种:遍历循环

    for(String str : list) {
       if(!list1.contains(str)) {
          return false;
       }
    }

    第二种:使用list中的retainAll方法

    java 取交集方法retainAll

    有两个集合A和B,判断这两个集合是否包含相同的对象或元素,可以使用retainAll方法:A.retainAll(B)。如果存在相同元素,A仅保留相同的元素。如果不存在相同元素,A会变为空。

    总的来说:如果集合A和集合B是完全相同的集合,也会返回false。两个集合没有交集,才会返回true

    第三种:使用md5的加密算法(可以了解,最好不要使用,比第一种循环比较还慢)

    String str = SecureUtil.md5(list.toString());     
    String str1 = SecureUtil.md5(list1.toString());
    return str.equals(str1);

    第四种:java8的stream流

    return list.stream().sorted().collect(Collectors.joining())
    .equals(list1.stream().sorted().collect(Collectors.joining()));

    第五种:使用list自带的sort方法先进性排序,然后转成toString去判断两个集合是否相等(速度最优,推荐使用

    list.sort(Comparator.comparing(String::hashCode));  
    list1.sort(Comparator.comparing(String::hashCode)); 
    return list.toString().equals(list1.toString());

     

     

     

    展开全文
  • 一,实现 1. 最简单粗暴的方法,遍历循环 package list.demo;...* 判断两个集合是否相等 */ public class CheckDiffList implements Serializable { public static void main(String[] args) { ...
  • 今天刷题的时候,遇到了一个操作,即判断两个数组或集合中元素是否相等。一下子忘记了要用哪个方法,于是乎直接写了一个for循环。后来才想起要用equals()这个方法,特此写一篇博文,加强一下记忆。 public class ...
  • C# 判断两个集合中元素是否相等

    千次阅读 2020-12-28 13:43:38
    今天在写接口时,需要根据当前传入的集合数据,和上次传入的集合数据,做出不同的逻辑处理. 可以使用SequenceEqual这个方法,非常实用 Demo: List<long> nums = new List<long>() { 1,2,30,50,60,5,9...
  • java基础--集合--判断两个集合元素以及元素顺序是否相等 1 ListUtils.isEqualList ListUtils.isEqualList(Collection<?> list1, Collection<?> list2)import org.apache.commons.collections4....
  • C++ 判断集合是否相等

    2021-11-05 23:58:09
    (集合元素可能需要去重) 。 如果两个集合相等,则输出"yes",否则输出"no" 【输入格式】 两行分别表示集合 A 和 B ,每一行先输入一个数 n 表示集合的大小,接下来输入 n 个数表示集合的元素 【输出格式】 ...
  • 判断集合中的某个元素的某个属性是否全部相等 List<User> users = new ArrayLiat<>(); //获取User对象age属性,distinct()去重,count()获取去重后的集合数 long count = users.stream().map(User::...
  • = null){ // 对list集合进行排序 // 使参与比较的list集合都有相同的排序规则 Collections.sort(list); listBuf.append(list.toString()); } return listBuf.toString(); } 输出结果: [A, C, D] [A, C, D] true
  • 现在有两个对象,他们的一个属性是list,很明显两个对象的list里面的对象,都是相等的,只是这2个list里面的顺序不一致,导致这2个对象被判断为不相等啦,这就是问题,现在要解决这个问题。 问题图如下: 可以...
  • java 判断 集合中存在元素

    千次阅读 2020-03-22 21:08:37
    数组:转为List再判断:Arrays.asList(数组名) List :contains(值) Set:去重复可以使用HashSet去重复 [] 数组 转为List: Array.asList(数组) Set<类型> set = new HashSet<类型>(某List); set....
  • 今天小编就为大家分享一篇关于判断List和Map是否相等并合并List相同的Map,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 主要介绍了从源码的角度浅析HashMap、TreeMap元素的存储和获取元素的逻辑;从Map与Set之间的关系浅析常用的Set中元素的存储和判断是否重复的逻辑,需要的朋友可以参考下
  • package test0420; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List;... * @description 判断两个list的元素值是否完全一样 */ public
  • 主要介绍了Java提取2个集合中的相同和不同元素代码示例,涉及对removeall方法的简单介绍,然后分享了主要的示例代码,具有一定借鉴价值,需要的朋友可以参考下。
  • (集合元素可能需要去重) 。 如果两个集合相等,则输出"yes",否则输出"no" 【输入格式】 两行分别表示集合 A 和 B ,每一行先输入一个数 n 表示集合的大小,接下来输入 n 个数表示集合的元素 【输出格式】 按要求...
  • 今天小编就为大家分享一篇Java判断List相同值元素的个数实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  •  实际上,调用contains(Object obj)方法时,会遍历List的每一个元素,再调用每个元素的equals()方法去跟contains()方法的参数进行比较,如果有一个元素的equals()方法返回true则contains()方法返回true,否则...
  • 如何判断两个List集合内容是否相等?

    千次阅读 2020-08-26 22:22:42
    如何判断两个集合内容是否相等?... * 判断集合元素是否相同 * @param list_a 集合a * @param list_b 集合b * @param <Q> 泛型 * @return */ public static <Q> boolean equals(List<Q> list_a
  • Qt_判断集合中元素是否全部相同

    千次阅读 2020-04-10 14:13:01
    判断元素是否相同,遍历跟第一个比就行,有不同直接返回 情况是有一个设备组,里边包含若干设备。 设备全开,组开关显示开 设备全关,组开关显示关 设备状态不一致,禁用组开关 逻辑 判断组内状态是否相同 if(相同) ...
  • a和b两个list中元素是一样的,只是顺序不一样,我们怎么判断他们呢? from collections import Counter a=[1,2,3,4,5,6,7,8,9] b=[9,8,7,6,5,4,3,2,1] a = Counter(a) b = Counter(b) print (dict(a)==dict(b)) # ...
  • 搬砖,引用来源于检测列表的所有元素是否相等 代码如下: def all_equal(lst): return lst[1:] == lst[:-1] print(all_equal([1, 2, 3, 4, 5, 6])) # False print(all_equal([1, 1, 1, 1])) # True 原理:我们...
  • 最近要修改excel导入错误提示功能,将原有的throw抛出换成一次性提示。方案很简单用list贯穿接受。...可判断row是否为null,或者判断Cell.CELL_TYPE_BLANK和cell.getCellType()是否相等即可。 将这些为空的放入...
  • 判断两个集合元素是否相同 1)基本数据类型 public static void main(String[] args) { List&lt;Integer&gt; list1=new ArrayList&lt;Integer&gt;(); list1.add(1); list1.add(2); list1....
  • List 有方法contains可以判断出List是否已经有这个值。如果想去重复可以使用HashSet去重复。List&lt;String&gt; list = new ArrayList&lt;String&gt;(new HashSet&lt;String&gt;(a)); 1....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,779
精华内容 42,711
关键字:

如何判断集合中的元素相等