精华内容
下载资源
问答
  • 遍历HashSet

    2015-11-20 11:01:18
    import java.util.HashSet; import java.util.Iterator; public class Test { public static void main(String[] args) { HashSet hashSet = new HashSet(); hashSet.add(new Integer(1)); // 向集合中添加...
    import java.util.HashSet;
    
    import java.util.Iterator;


    public class Test {
    public static void main(String[] args) {
    HashSet hashSet = new HashSet();
    hashSet.add(new Integer(1)); // 向集合中添加一个整数
    hashSet.add("a"); // 向集合中添加一个字符串
    int x[] = { 1, 2, 3, 4, 5 };
    hashSet.add(x); // 向集合中添加一个数组
    Iterator it = hashSet.iterator();
    while (it.hasNext()) {
    Object obj = it.next();
    if (obj.getClass().isArray()) {//if(obj instanceof int[]){
    int[] array = (int[]) obj;
    for (int i = 0; i < array.length; i++) {
    System.out.println("========" + array[i]);
    }
    }
    }
    }
    }
    展开全文
  • java之HashSet

    2018-09-10 19:47:56
    HashSet实现了Set的接口 HashSet的特点:元素无序,切唯一,元素的值可以是null但只能有一个; HashSet的底层使用的是哈希表  哈希表:散列表. 哈希表:一个一维数组+N个链表; 哈希表的工作原理:   在HashSet中...

    HashSet实现了Set的接口

    HashSet的特点:元素无序,切唯一,元素的值可以是null但只能有一个;

    HashSet的底层使用的是哈希表

               哈希表:散列表.

    哈希表:一个一维数组+N个链表;

    哈希表的工作原理:

                      

    在HashSet中元素的值都存到了HashMap的键值对的key上,而value时有一个统一的值,private static final Object PRESENT = new Object();

    HashSet插入

    当有新值加入时,底层的HashMap会判断Key值是否存在(HashMap细节请移步深入理解HashMap),如果不存在,则插入新值,同时这个插入的细节会依照HashMap插入细节;如果存在就不插入

    源码分析:

    public class HashSet<E>  
        extends AbstractSet<E>  
        implements Set<E>, Cloneable, java.io.Serializable  
    {  
        static final long serialVersionUID = -5024744406713321676L;  
    
        // 底层使用HashMap来保存HashSet中所有元素。  
        private transient HashMap<E,Object> map;  
    
        // 定义一个虚拟的Object对象作为HashMap的value,将此对象定义为static final。  
        private static final Object PRESENT = new Object();  
    
        /** 
         * 默认的无参构造器,构造一个空的HashSet。 
         *  
         * 实际底层会初始化一个空的HashMap,并使用默认初始容量为16和加载因子0.75。 
         */  
        public HashSet() {  
        map = new HashMap<E,Object>();  
        }  
    
        /** 
         * 构造一个包含指定collection中的元素的新set。 
         * 
         * 实际底层使用默认的加载因子0.75和足以包含指定 
         * collection中所有元素的初始容量来创建一个HashMap。 
         * @param c 其中的元素将存放在此set中的collection。 
         */  
        public HashSet(Collection<? extends E> c) {  
        map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));  
        addAll(c);  
        }  
    
        /** 
         * 以指定的initialCapacity和loadFactor构造一个空的HashSet。 
         * 
         * 实际底层以相应的参数构造一个空的HashMap。 
         * @param initialCapacity 初始容量。 
         * @param loadFactor 加载因子。 
         */  
        public HashSet(int initialCapacity, float loadFactor) {  
        map = new HashMap<E,Object>(initialCapacity, loadFactor);  
        }  
    
        /** 
         * 以指定的initialCapacity构造一个空的HashSet。 
         * 
         * 实际底层以相应的参数及加载因子loadFactor为0.75构造一个空的HashMap。 
         * @param initialCapacity 初始容量。 
         */  
        public HashSet(int initialCapacity) {  
        map = new HashMap<E,Object>(initialCapacity);  
        }  
    
        /** 
         * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 
         * 此构造函数为包访问权限,不对外公开,实际只是是对LinkedHashSet的支持。 
         * 
         * 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。 
         * @param initialCapacity 初始容量。 
         * @param loadFactor 加载因子。 
         * @param dummy 标记。 
         */  
        HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
        map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
        }  
    
        /** 
         * 返回对此set中元素进行迭代的迭代器。返回元素的顺序并不是特定的。 
         *  
         * 底层实际调用底层HashMap的keySet来返回所有的key。 
         * 可见HashSet中的元素,只是存放在了底层HashMap的key上, 
         * value使用一个static final的Object对象标识。 
         * @return 对此set中元素进行迭代的Iterator。 
         */  
        public Iterator<E> iterator() {  
        return map.keySet().iterator();  
        }  
    
        /** 
         * 返回此set中的元素的数量(set的容量)。 
         * 
         * 底层实际调用HashMap的size()方法返回Entry的数量,就得到该Set中元素的个数。 
         * @return 此set中的元素的数量(set的容量)。 
         */  
        public int size() {  
        return map.size();  
        }  
    
        /** 
         * 如果此set不包含任何元素,则返回true。 
         * 
         * 底层实际调用HashMap的isEmpty()判断该HashSet是否为空。 
         * @return 如果此set不包含任何元素,则返回true。 
         */  
        public boolean isEmpty() {  
        return map.isEmpty();  
        }  
    
        /** 
         * 如果此set包含指定元素,则返回true。 
         * 更确切地讲,当且仅当此set包含一个满足(o==null ? e==null : o.equals(e)) 
         * 的e元素时,返回true。 
         * 
         * 底层实际调用HashMap的containsKey判断是否包含指定key。 
         * @param o 在此set中的存在已得到测试的元素。 
         * @return 如果此set包含指定元素,则返回true。 
         */  
        public boolean contains(Object o) {  
        return map.containsKey(o);  
        }  
    
        /** 
         * 如果此set中尚未包含指定元素,则添加指定元素。 
         * 更确切地讲,如果此 set 没有包含满足(e==null ? e2==null : e.equals(e2)) 
         * 的元素e2,则向此set 添加指定的元素e。 
         * 如果此set已包含该元素,则该调用不更改set并返回false。 
         * 
         * 底层实际将将该元素作为key放入HashMap。 
         * 由于HashMap的put()方法添加key-value对时,当新放入HashMap的Entry中key 
         * 与集合中原有Entry的key相同(hashCode()返回值相等,通过equals比较也返回true), 
         * 新添加的Entry的value会将覆盖原来Entry的value,但key不会有任何改变, 
         * 因此如果向HashSet中添加一个已经存在的元素时,新添加的集合元素将不会被放入HashMap中, 
         * 原来的元素也不会有任何改变,这也就满足了Set中元素不重复的特性。 
         * @param e 将添加到此set中的元素。 
         * @return 如果此set尚未包含指定元素,则返回true。 
         */  
        public boolean add(E e) {  
        return map.put(e, PRESENT)==null;  
        }  
    
        /** 
         * 如果指定元素存在于此set中,则将其移除。 
         * 更确切地讲,如果此set包含一个满足(o==null ? e==null : o.equals(e))的元素e, 
         * 则将其移除。如果此set已包含该元素,则返回true 
         * (或者:如果此set因调用而发生更改,则返回true)。(一旦调用返回,则此set不再包含该元素)。 
         * 
         * 底层实际调用HashMap的remove方法删除指定Entry。 
         * @param o 如果存在于此set中则需要将其移除的对象。 
         * @return 如果set包含指定元素,则返回true。 
         */  
        public boolean remove(Object o) {  
        return map.remove(o)==PRESENT;  
        }  
    
        /** 
         * 从此set中移除所有元素。此调用返回后,该set将为空。 
         * 
         * 底层实际调用HashMap的clear方法清空Entry中所有元素。 
         */  
        public void clear() {  
        map.clear();  
        }  
    
        /** 
         * 返回此HashSet实例的浅表副本:并没有复制这些元素本身。 
         * 
         * 底层实际调用HashMap的clone()方法,获取HashMap的浅表副本,并设置到HashSet中。 
         */  
        public Object clone() {  
            try {  
                HashSet<E> newSet = (HashSet<E>) super.clone();  
                newSet.map = (HashMap<E, Object>) map.clone();  
                return newSet;  
            } catch (CloneNotSupportedException e) {  
                throw new InternalError();  
            }  
        }  
    }  

    HashSet的便利:

              HashSet的便利方式有两种:增强for循环,迭代器

    注意

    • 说白了,HashSet就是限制了功能的HashMap,所以了解HashMap的实现原理,这个HashSet自然就通
    • 对于HashSet中保存的对象,主要要正确重写equals方法和hashCode方法,以保证放入Set对象的唯一性
    • 虽说时Set是对于重复的元素不放入,倒不如直接说是底层的Map直接把原值替代了(这个Set的put方法的返回值真有意思)
    • HashSet没有提供get()方法,愿意是同HashMap一样,Set内部是无序的,只能通过迭代的方式获得
    展开全文
  • HashSet存储原理

    2019-10-02 23:05:16
    HashSet: 底层哈希表结构(数组+链表+红黑树),由哈希表保证元素唯一,底层是HashMap实现 哈希表的原理: 哈希表底层是数组+链表+红黑树,依赖于hashCode和equals方法 数组存储元素哈希值, 哈希值相同的存储在链表中,...
     HashSet: 底层哈希表结构(数组+链表+红黑树),由哈希表保证元素唯一,底层是HashMap实现
     哈希表的原理: 哈希表底层是数组+链表+红黑树,依赖于hashCode和equals方法
         数组存储元素哈希值, 哈希值相同的存储在链表中,链表节点超过8个,链表换成红黑树,因为红黑树效率高
         1.调用元素的hashCode()方法,便利数组,有没有这个哈希值,没有就直接存储
         2.数组中已经有哈希值相同的,那么就调用元素的equals()方法,和哈希值相同的元素进行一一比较
         3.equals()方法比较,有相等的就不存储,没有就存储
            //Student类中只重写了HashCode()方法,equals和toString都没有重写
    
            HashSet<Student> set = new HashSet<>();
            Student s1 = new Student("aaa", 18);
            set.add(s1);
            Student s2=new Student("aaa", 18);
            set.add(s2);
            System.out.println("s1:"+s1);//s1:day3.Student@2d93b2
    
            System.out.println("s2:"+s2);//s2:day3.Student@2d93b2
    
            System.out.println(s1==s2);//false
    
            System.out.println(s1.equals(s2));//false
    •  s1和s2的哈希值是一样的,因为重写了HashCode方法
    • s1和s2的打印结果为什么是一样的?难道地址值一样?明明是两个对象,   这是因为打印操作调用的是Object类中的toString方法,该方法的返回值是 包名.类名@哈希值的16进制  ,  哈希值一样打印的结果当然一样
    • 也就是说,打印的对象值,在这里不是对象的真是地址值,所以s1.equals(s2) 和s1==s2返回的都是false,因为他们真是地址不一样.
    展开全文
  • 源码之HashSet

    2018-10-28 00:34:04
    构造函数 public HashSet() { map = new HashMap<>(); } public HashSet(Collection<? extends E> c) { map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16))...

    构造函数

        public HashSet() {
            map = new HashMap<>();
        }
    
        public HashSet(Collection<? extends E> c) {
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
            addAll(c);
        }
    
        public HashSet(int initialCapacity, float loadFactor) {
            map = new HashMap<>(initialCapacity, loadFactor);
        }
    
        public HashSet(int initialCapacity) {
            map = new HashMap<>(initialCapacity);
        }
    
       /**
         * Constructs a new, empty linked hash set.  (This package private
         * constructor is only used by LinkedHashSet.) The backing
         * HashMap instance is a LinkedHashMap with the specified initial
         * capacity and the specified load factor.
         *
         * @param      initialCapacity   the initial capacity of the hash map
         * @param      loadFactor        the load factor of the hash map
         * @param      dummy             ignored (distinguishes this
         *             constructor from other int, float constructor.)
         * @throws     IllegalArgumentException if the initial capacity is less
         *             than zero, or if the load factor is nonpositive
         */
        HashSet(int initialCapacity, float loadFactor, boolean dummy) {
            map = new LinkedHashMap<>(initialCapacity, loadFactor);
        }

    分析:
    HashSet底层是HashMap实现的,你看最后一个构造函数就会很奇怪,这dummy的参数干啥的 ,啥也没用。不过这个看说明就知道了,只是为了实现构造函数的重载,跟其他区别开来的(如果不明白有必要看下重载内容)。

    add方法

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

    分析:
    这就很简单可以知道了,就是将E作为HashMap的key,所有的key都指向PRESENT对象,因为我们都知道,key是不允许重复的,而value可以。

    另外这里没有HashMap的那种get方法去获取key的,只能通过迭代器去便利里面的值。

    总结:
    1.它不是线程安全的
    2.它是由HashMap实现的
    3.通过map.put(key,PRESENT)方式把所有key指向同一个对象
    4.访问只能通过迭代器访问。

    转载于:https://blog.51cto.com/4837471/2309838

    展开全文
  • 遍历 HashSet 的方法

    千次阅读 2019-09-28 11:01:31
    遍历 HashSet 的方法 import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class Test { public static void main(String[] args) { Set<String> set = new Has...
  • Set HashSet Iterator

    2012-10-17 14:21:30
    public class HashSetextends AbstractSetimplements Set, Cloneable, Serializable 从类 java.util.AbstractSet 继承的方法
  • Java的HashSet的对象遍历

    万次阅读 2014-08-12 23:03:44
    import java.util.Set;...import java.util.HashSet; import java.util.Iterator; public class SetTest { public static void main(String[] args) { Set set = new HashSet(); set.add("aaa"); set.add(
  • java 利用HashSet去重并保持排序

    千次阅读 2018-03-29 21:19:17
    java 利用HashSet去重并保持排序 @(技能提升)[Java, 排序,ArrayList,HashSet] ...在java中 对arrayList 去重, 最便利的方式即利用HashSet的不可重复特性,直接去重: List&lt;Result&gt; resultList ...
  • 没有索引,所以也不能使用普通for循环进行便利。 (所有实现Set接口的类具有以上特点。) HashSet集合 此类实现Set接口,由哈希表(实际上是HashMap实例)支持。它不保证集合的迭代顺序; 特别是,它不保证订单会...
  • 遍历ArrayList和HashSet

    2020-02-18 13:49:31
    import java.util.HashSet; import java.util.Set; public class simplifyArray { public static void main(String[] args) { int[] arr={1,2,2,2,3,4,4,5,6,7,0,0,-1,-3,100,200,1,1,1}; int num=remove...
  • HashMap HashSet源码分析

    2016-11-20 17:50:28
    的到键值对 便利根据key和上面相同的办法计算出table【位置】然后便利即可通过equals比较 final Entry,V> getEntry(Object key) { int hash = (key == null) ? 0 : hash(key.hashCode()); for (Entry,V> e = ...
  • 主要介绍常用的一个HashSet集合 //Set 集合的增删改查 无序 没有重复对象 import java.util.*; //导包 public class Setzsgc { public static void main(String[] args) { HashSet hs = new HashSet(); //增加 ...
  • HashSet概述 内部字段及构造方法 存储元素 删除元素 包含元素 总结 HashSet概述   从前面开始,已经分析过集合中的List和Map,今天来介绍另一种集合元素:Set。这是JDK对HashSet的介绍: This ...
  • Java中的集合——HashSet和LinkedHashSet

    千次阅读 2018-08-06 16:58:03
    首先Set集合,无索引,不可重复,无序(存取顺序不一致)set 和 collection 相比没有特有的方法功能,所以我们直接来说说它的子类 HashSet HashSet的概述 该类实现 Set 接口,由哈希表(实际上是一个 HashMap 实例...
  • 红黑树、HashSet、Map

    2021-07-02 18:25:07
    元素没有索引 HashSet集合的便利方式 1.迭代器遍历 2.增强for遍历 HashSet的底层原理 HashSet集合底层是哈希表结构,要理解哈希表首先得理解什么是哈希值。 什么是哈希值? 每一个对象都有哈希值,它是通过对象的...
  • hashmap与hashtable 1,hashmap的键值都可以为空,hashtable不可以为空 2,hashmap是非同步,hashtable是同步 3,hashmap是继承的abstractmap,hashtable是继承的dictionary。... 1,hashset是实现的set接口,ha
  • Java 遍历 HashSet 为什么输出是有序的

    千次阅读 2017-08-31 22:52:24
    “不保证有序”和“保证无序”不等价,HashSet的iterator是前者而不是后者,所以在一次运行中看到有序的结果也是正常的,但不能依赖这个有序行为。 况且HashSet并不关心key的“排序”,就算其iterator“有序”通常...
  • 一 HashSet    (1) HashSet 中不能存放形相同的对象,比较两个对象是否相同,HashSet 内部实现类这样比较: 先比较两个对象的Hash code 是否相等,如果相等,在比较两个对象是否equals ,因此,要想使用...
  • //通过迭代器遍历HashSet Iterator it = hash.iterator(); while(it.hasNext()) { System.out.println(it.next()); } System.out.println("=================="); //通过加强for循环遍历HashSet for(String s: ...
  •  Java非常多的时间,应使用HashSet搜索功能,类的则定义,是HashSet类型的,我们定义数据成员之后,不好直接调用add函数来实现初始化,这个时候怎么办?  我们能够这样来做: public static final ...
  • Java 集合系列之 Set架构 TreeSet HashSet 详细介绍(源码解析)和使用示例
  • 一、HashSet 二、TreeSet 三、LinkedHashSet Set注重独一无二的性质,该体系集合用于存储无序(存入和取出的顺序不一定相同)元素,值不能重 复。对象的相等性本质是对象hashCode值(java是依据对象的内存地址计算...
  • 有时候我们在类成员定义时,当这个类成员类型为 HashSet时,我们可以不方便调用 add函数进行初始化,所以可以采用下面的便捷方式来进行初始化 1 public class MyTest{ 2 3 final HashSet<String> set...
  • **给定一个整数数组,判断是否存在重复元素。...解:便利Hash表来解决这个问题,先来看一下HashSet与HashMap的区别 所以相比之下,HashSet更合适 class Solution { public boolean containsDuplicate(int
  • 1、AbstractSet类是一个便利类,它扩展了AbstractCollection类并实现Set接口,AbstractSet类提供equals方法和hashCode方法的具体实现。由于AbstractSet类没有实现size方法和iterator方法,所以,AbstractSet类是一个...
  • 又突然想看源码了,继续深入Java基础系列。今天是研究JavaAPI的HashTable和HashSet(顺带讨论线程安全问题)。今天仔细研究HashTable与HashSet源码、线程、使用注意等问题。
  • Set的实现类都是基于Map来实现的(HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的)。 Set 是继承于Collection的接口。它是一个不允许有重复元素的集合。 AbstractSet 是一个抽象类,它继承...
  • 别慌别慌,这一篇来说说集合框架里最偷懒的一个家伙——HashSet,为什么说它是最偷懒的呢,先留个悬念,看完本文之后,你就会知道所言不假了。  本篇将从以下几点来进行介绍:  1.HashSet的特点和使用场景  2....
  • AbstractCollection实现了Set中的绝大部分函数,为Set的实现类提供了便利 深拷贝对引用数据类型的成员变量的对象图中所有的对象都开辟了内存空间,修改对象不会影响原来的对象 而浅拷贝只是传递地址指向,新的对象并...
  • 文章目录1 Set接口概述Api2 HashSet概述构造方法Api源码3 LinkedHashSet概述构造方法4 TreeSet概述构造方法Api PM Lesson2 1 hours (01) Set 是继承于Collection的接口。它是一个不允许有重复元素的集合。 (02) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,219
精华内容 1,687
关键字:

hashset便利