精华内容
下载资源
问答
  • JAVA Set 交集,差集,并集

    万次阅读 多人点赞 2017-07-11 09:04:49
    /** * Created by yuhui on 2017/7/11 0011. */ import java.util.HashSet;...import java.util.Set;public class TestSet { public static void main(String[] args) { Set<String> result = new HashSet

    “无意中发现了一个巨牛的人工智能教程,忍不住分享一下给大家。教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!觉得太牛了,所以分享给大家。点 这里 可以跳转到教程。”。

    /**
     * Created by yuhui on 2017/7/11 0011.
     */
    import java.util.HashSet;
    import java.util.Set;
    
    public class TestSet {
    
        public static void main(String[] args) {
    
            Set<String> result = new HashSet<String>();
            Set<String> set1 = new HashSet<String>() {
                {
                    add("王者荣耀");
                    add("英雄联盟");
                    add("穿越火线");
                    add("地下城与勇士");
                }   
            };
    
            Set<String> set2 = new HashSet<String>() {
                {
                    add("王者荣耀");
                    add("地下城与勇士");
                    add("魔兽世界");
                }
            };
    
            result.clear();
            result.addAll(set1);
            result.retainAll(set2);
            System.out.println("交集:" + result);
    
            result.clear();
            result.addAll(set1);
            result.removeAll(set2);
            System.out.println("差集:" + result);
    
            result.clear();
            result.addAll(set1);
            result.addAll(set2);
            System.out.println("并集:" + result);
    
        }
    
    }
    
    

    结果如下:

    交集:[王者荣耀, 地下城与勇士]
    差集:[英雄联盟, 穿越火线]
    并集:[王者荣耀, 英雄联盟, 魔兽世界, 地下城与勇士, 穿越火线]

    北京小辉微信公众号

    在这里插入图片描述

    大数据资料分享请关注

    在这里插入图片描述

    展开全文
  • Java Set对象去重

    万次阅读 多人点赞 2018-05-23 16:41:19
    我们可以知道Set集合是没有重复数据的特性,那么对于元素为对象 ...举一个例子:SetTest.java:class VO { private String name; private String addr; public VO(String name, String addr) { this.name = nam...

         我们可以知道Set集合是没有重复数据的特性,那么对于元素为对象 的情况是否也同样奏效?可以看一下。举一个例子:

    SetTest.java:

    class VO {
        private String name;
        private String addr;
    
        public VO(String name, String addr) {
            this.name = name;
            this.addr = addr;
        }
    
        @Override
        public String toString() {
            return "name: " + name + " addr:" + addr;
        }
    }
    
     @Test
     public void testSet() {
    
         Set<VO> vos = new HashSet<>();
    
         VO vo = new VO("wahaha", "sh");
    
         VO vo1 = new VO("wahaha", "bj");
    
         VO vo2 = new VO("wahaha", "sh");
    
         vos.add(vo);
         vos.add(vo1);
         vos.add(vo2);
    
         for (VO item : vos) {
             System.out.println(item.toString());
         }
     }

    结果为:

    name: wahaha addr:sh
    name: wahaha addr:bj
    name: wahaha addr:sh

    可见,对于各个字段值都相同的对象,并没有做去重操作。为什么呢,看一下JDK1.8中HashSet的数据结构:

    HashSet.java:

    实例化对象:

    /**
     * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
     * default initial capacity (16) and load factor (0.75).
     */
     public HashSet() {
        map = new HashMap<>();
     }

    可见new HashSet()操作实际上是new HashMap<>(),可见底层是以HashMap来实现的。

    HashSet.add方法

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

    HashMap.add方法

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }putVal(hash(key), key, value, false, true);
    }
    
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

    可以从上面的加粗字段看出,判断插入的key是否存在,要判断两点①hash值是否相同;②对应的值是否相同,前者要看hashCode()方法,后者要看equal()方法。下面我们来探索一下基本的数据类型和自定义类类型在计算hashCode和equal的区别,看一下如下代码:

    class VO {
        private String name;
        private String addr;
    
        public VO(String name, String addr) {
            this.name = name;
            this.addr = addr;
        }
    
        @Override
        public String toString() {
            return "name: " + name + " addr:" + addr;
        }
    }
    
    @Test
    public void testSet() {
        
       Set<VO> vos = new HashSet<>();
    
       VO vo = new VO("wahaha", "sh");
       VO vo1 = new VO("wahaha", "bj");
       VO vo2 = new VO("wahaha", "sh");
    
       Integer a = 2;
       Integer b = 2;
    
       String str1 = new String("abc");
       String str2 = new String("abc");
    
       System.out.println(a.equals(b));
       System.out.println(str1.equals(str2));
       System.out.println(vo.equals(vo2));
       
       System.out.println(a.hashCode() == b.hashCode());
       System.out.println(str1.hashCode() == str2.hashCode());
       System.out.println(vo.hashCode() == vo2.hashCode());
    
       vos.add(vo);
       vos.add(vo1);
       vos.add(vo2);
    
       for (VO item : vos) {
           System.out.println(item.toString());
       }
    }

    结果为:

    true
    true
    false
    true
    true
    false
    name: wahaha addr:sh
    name: wahaha addr:sh
    name: wahaha addr:bj

    java.lang.Integer.equals():两个对象对应的值一致则返回true。

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

    java.lang.String.equals()两个字符串对应的值一致则返回true

    public boolean equals(Object anObject) {
        if (this == anObject) {//同一个对象,必定是一致的
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {//对比每一个字符
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;//anObject不是String实例,那么返回false
    }

    java.lang.Object.equals():两个对象的引用是否一致,即两个的对象是否是同一个。

     

    public boolean equals(Object obj) {
        return (this == obj);
    }

    可见对于java.lang.Object.equals()来讲,两个new出来的对象肯定是不一致的,那么在HashMap数据结构中不会被判定成相同的对象(尽管值相同)。下面再看看hashCode的源码:

    java.lang.Integer.hashCode():

    @Override
    public int hashCode() {
        return Integer.hashCode(value);
    }
    
    public static int hashCode(int value) {
        return value;
    }

    java.lang.String.hashCode():

     

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
    
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

    java.lang.Object.hashCode():

    public native int hashCode();

    JDK8的默认hashCode的计算方法是通过和当前线程有关的一个随机数+三个确定值,运用Marsaglia's xorshift schema随机数算法得到的一个随机数。

    因此,以上可以看到Integer和String也都是根据具体的value值来计算hashCode,那么尽管两个引用不同但是值相同的对象,依然是想等的,但是Object则不同了。

    知道了原因,解决方法就简单了,那就是重载VO类的equals和hashCode方法,代码如下:

    SetTest.java:

    class VO {
        private String name;
        private String addr;
    
        public VO(String name, String addr) {
            this.name = name;
            this.addr = addr;
        }
    
        @Override
        public String toString() {
            return "name: " + name + " addr:" + addr;
        }
    
        /**
         * 如果对象类型是User,先比较hashcode,一致的场合再比较每个属性的值
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null)
                return false;
            if (this == obj)
                return true;
            if (obj instanceof VO) {
                VO vo = (VO) obj;
    
                // 比较每个属性的值一致时才返回true
                if (vo.name.equals(this.name) && vo.addr.equals(this.addr))
                    return true;
            }
            return false;
        }
    
        /**
         * 重写hashcode方法,返回的hashCode一样才再去比较每个属性的值
         */
        @Override
        public int hashCode() {
            return name.hashCode() * addr.hashCode();
        }
    } // class
    
    @Test
    public void testSet() {
        
       Set<VO> vos = new HashSet<>();
    
       VO vo = new VO("wahaha", "sh");
       VO vo1 = new VO("wahaha", "bj");
       VO vo2 = new VO("wahaha", "sh");
    
       vos.add(vo);
       vos.add(vo1);
       vos.add(vo2);
    
       for (VO item : vos) {
           System.out.println(item.toString());
       }
    
    }

     

    结果:

     

    name: wahaha addr:sh
    name: wahaha addr:bj

    在阿里巴巴Java开发是手册的集合处理中需要强制遵循如下规则:

    1)只要重写equals,就必须重写hashCode;

    2)因为Set存储的是不重复的对象,依据hashCode和equals进行判断,所以Set存储的对象必须重写这两个方法。

    3)如果自定义对象做为Map的键,那么必须重写hashCode和equals。

    正例:String重写了hashCode和equals方法,所以我们可以非常愉快的使用String对象作为key来使用。

    以上。

     

    Author:忆之独秀

    Email:leaguenew@qq.com

    注明出处:https://blog.csdn.net/lavorange/article/details/80420087

     

     

    展开全文
  • java set转array

    千次阅读 2019-09-26 19:48:44
    java set转array Long[] arr = set1.stream().toArray(n -> new Long[n]);

    java set转array

    Long[] arr = set1.stream().toArray(n -> new Long[n]);
    
    展开全文
  • java set初始化

    千次阅读 2017-11-08 11:41:10
    java set初始化 set在执行add方法时,多次报空指针异常,后来发现Set初始化时,如果是 Set set = null; 这样的话,在执行 set.add(element)的时候会报空指针异常,具体原因不知,如果这样初始化: ...

    java set初始化

    set在执行add方法时,多次报空指针异常,后来发现Set初始化时,如果是

    Set<Type> set = null;

    这样的话,在执行 set.add(element)的时候会报空指针异常,具体原因不知,如果这样初始化:

    Set<Type> set = new HashSet<>();

    就不会,而

    Set<Type> set = new Set<>();

    会提示Cannot instantiate the type Set。

      总结来看,对java集合类的理解还是不够深入,接下来两天准备细细抓一抓这块儿

    展开全文
  • Java Set集合详解及Set与List的区别

    万次阅读 2018-06-04 23:46:50
    Java中的Set集合是继承Collection的接口,是一个不包含重复元素的集合。 下图是Set集合的源码。 Set和List都是以接口的形式来进行声明。Set主要包含三种存放数据类型都变量,分别是HashSet,LinkedHashSet,...
  • Java Set集合

    千次阅读 2019-11-01 19:47:43
    Set接口 HashSet实现类 https://www.bilibili.com/video/av55246614/?p=255 用到再更 哈希值 HashSet集合存储数据的结构(哈希表) Set存储数据不重复的原理 HashSet存储自定义类型元素 LinkedHashSet...
  • Java Set集合的详解

    万次阅读 多人点赞 2016-07-26 22:39:17
    一,Set Set:注重独一无二的性质,该体系集合可以知道某物是否已近存在于集合中,不会存储重复的元素 用于存储无序(存入和取出的顺序不一定相同)元素,值不能重复。 对象的相等性  引用到堆上同一个对象的两个...
  • 展开全部用循环或者迭代器创建set的iteratorSet set = new HashSet();Iterator it = set.iterator();while(it.hasNext())//判断是否有下一个it.next()取出元素======================================import java....
  • Java Set容器添加相同元素的返回值判断代码如下:   /**  * @from www.everycoding.com  * @Description:Java Set容器添加相同元素的返回值判断  */ public class SetAdd { public static...
  • java Set原理分析

    千次阅读 2018-05-12 17:52:12
    java中的Set都是用对应的Map实现的。比如HashSet是由HashMap实现的,TreeSet是由TreeMap实现的。 只要将map的value都设置成null,那么它们的key就组成了一个Set
  • 关于Java Set的初始化方法

    万次阅读 2019-02-19 15:15:17
    定义了一个Set后,我想把它初始化一下. 方法一. 利用了add函数, 如下: public static void main(String[] args) { Set<String> testSet = new HashSet<String>(); testSet.add("Monday"); test...
  • java set集合排序

    万次阅读 2017-11-14 13:16:47
    Set set = new HashSet(); set.add("aaaa"); set.add("bbbb"); List list = new ArrayList(set) Collections.sort(list);
  • java set 转为 map

    千次阅读 2017-10-27 18:57:42
     * set 转换成 map  * @param set  * @return  */ private Map setToMap (Set set) { Map map = new HashMap(); if (set == null) { return null; } Iterator iterator = set.iterator
  • java set集合详解

    千次阅读 2018-07-23 09:59:00
    一,Set Set:注重独一无二的性质,该体系集合可以知道某物是否已近存在于集合中,不会存储重复的元素 用于存储无序(存入和取出的顺序不一定相同)元素,值不能重复。 对象的相等性  引用到堆上同一个对象的两个...
  • Java set 基本使用方法

    千次阅读 2017-11-05 22:49:03
    package StringTest; import java.util.HashSet; import java.util.Hashtable; import java.util.Iterator; import java.util.Random;...import java.util.Set; public class StringT { public static void main(Stri
  • java set 倒序 排列

    千次阅读 2017-05-12 09:48:39
    set 倒序 排列
  • Java Set 排序

    千次阅读 2016-07-11 17:02:07
    <textarea cols="50" rows="15" name="code" class="java"> final TreeSet ts = new TreeSet(va); ts.comparator(); System.out.println(ts); TreeSet中的存储是有序的。 参考网站: CSDN...
  • import java.util.*; public class test{ public static void main(String[] args){ HashSet<Integer> set1=new HashSet(); HashSet<Integer> set2=new HashSet(); set1.add(1); set2=set1; set2.add(2); ...
  • java set的不重复性

    千次阅读 2016-11-03 11:21:54
    javaset可以不重复子项
  • Java Set】1.Set集合的详解

    千次阅读 2018-08-10 16:17:25
    一、Set Set注重独一无二的性质,该体系集合可以知道某...如果对两个引用调用hashcode方法,会得到相同的结果,如果对象所属的类没有覆盖object的hashcode方法的话,hashcode会返回每个对象特有的序号(java是依据...
  • 看书说散列集(表)即hashtable可以快速查找元素。但是据我所知,hashset并没有查找元素的方法。 如果要快速找到一个元素,首先要获得该元素的hashcode,但是我也没见过什么保存hashcode的代码。...
  • Java Set集合去重机制

    万次阅读 2016-03-21 15:38:50
    关于java里面的集合,大家经常利用到Set集合没有重复数据的特性,来进行数据的去重,那么去重的原理是怎么样的呢?
  • set中的元素是不能相等重复的,这一点我知道,那么怎样才是(不)重复呢? 是hashcode相等?是地址相同?是元素的equal返回true? 猜测:先判断是不是同一个引用(地址),再判断equal 我自己做了...
  • java set取交集,差集,并集

    千次阅读 2018-09-26 10:02:43
    import java.util.Set; public class TestSet {  public static void main(String[] args) {  Set&lt;String&gt; result = new HashSet&lt;String&gt;();  Set&lt;Stri...
  • Java set集合 交集,并集,差集

    千次阅读 2017-08-18 10:25:18
    import java.util.HashSet; import java.util.Set; public class TestSet { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub
  • JavaSet的源码分析

    千次阅读 2012-03-15 23:12:55
    Java中,set能保证列表中元素唯一,map就是用来key-value用的东西。 先看Set。 首先Set是个接口,最常见的实现有HashSet,LinkedHashSet,和同步Set。 看HashSet的源码,其他应该类似(只是加上了特定功能,比如...
  • 利用Java Set 去除重复object

    万次阅读 2013-05-31 11:16:59
    import java.util....import java.util.Set; /** * 编写者:CP * 编写日期:2011-9-7 * 类描述:set集合针对String 类型和8大基础数据类型 过滤掉重复数据,如果存放的是其他类型对象,则需要重写hashCode方
  • java set集合的理解与学习

    千次阅读 2016-06-12 23:22:27
    java 集合是用来存储数量不等的多个对象,并可以实现常用的栈,队列等,还可以保存具有映射关系的关联数组,集合下面分为,set ,list,map   首先set 集合就像一个罐子,多个对象丢进去没有明显的关系,但是有...
  • Java Set Delete Remove

    千次阅读 2010-03-07 21:45:00
    // 删除时必须通过iterator.remove()来执行,不能直接使用set的remove()来执行,不然会出现java.util.ConcurrentModificationException异常/* Iterator delIter = keySet.iterator(); while(delIter.hasNext()){ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,161
精华内容 56,864
关键字:

javaset

java 订阅