精华内容
下载资源
问答
  • HashSet使用

    2018-07-23 13:45:10
    HashSet使用 1.HashSet 特点:  1.无序,不可重复  2.容量自动增长。   2.存储原理:  向Set中添加对象时,首先调用此对象所在类的hashCode()方法,计算次对象的哈希值,  此哈希值决定了此对象在Set中存放的...

    HashSet使用
    1.HashSet 特点:
        1.无序,不可重复
        2.容量自动增长。
        
    2.存储原理:
        向Set中添加对象时,首先调用此对象所在类的hashCode()方法,计算次对象的哈希值,
        此哈希值决定了此对象在Set中存放的位置;若此位置没有被存储对象则直接存储,
        若已有对象则通过对象所在类的equals()比较两个对象是否相同,相同则不能被添加。
        
        添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。
        要求重写equals() 和 hashCode()方法保持一致。

    3.使用场景:
       所有的技术都是为了转化为生产力,所以要知道如何取使用技术
       如购物车对象转化为订单对象,获取购物车不重复的库存地址
       
    4.hashSet没有get方法,所以遍历的时候,有两种方法,一种是通过迭代器,一种是通过增强for循环

    例子

    没有重写equals()和hashCode类添加相同元素,可以添加进去:

    package test;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class TestSet {
    	
         public static void main(String[] args){
        	  Set<Person> set = new HashSet<>();
        	  set.add(new Person(1, 1));
        	  set.add(new Person(1, 3));
        	  set.add(new Person(1, 1));
        	//  1.迭代器
        	  Iterator iterator = set.iterator();
        	  while (iterator.hasNext()) {
    			Person person = (Person) iterator.next();
    			System.out.println("迭代器:"+person);
    		} 	 
         }
    
    }
    

        结果:

               迭代器:Person [x=1, y=3]
               迭代器:Person [x=1, y=1]
              迭代器:Person [x=1, y=1]

    重写了equals()方法和hashCode()后

    package test;
    
    public class Person {
        private  int x;
        private  int y;
    	public int getX() {
    		return x;
    	}
    	public void setX(int x) {
    		this.x = x;
    	}
    	public int getY() {
    		return y;
    	}
    	public void setY(int y) {
    		this.y = y;
    	}
    	@Override
    	public String toString() {
    		return "Person [x=" + x + ", y=" + y + "]";
    	}
    	public Person(int x, int y) {
    		super();
    		this.x = x;
    		this.y = y;
    	}
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + x;
    		result = prime * result + y;
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (x != other.x)
    			return false;
    		if (y != other.y)
    			return false;
    		return true;
    	}  
           
    	
    }
    
    package test;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class TestSet {
    	
         public static void main(String[] args){
        	  Set<Person> set = new HashSet<>();
        	  set.add(new Person(1, 1));
        	  set.add(new Person(1, 3));
        	  set.add(new Person(1, 1));
        	//  1.迭代器
        	  Iterator iterator = set.iterator();
        	  while (iterator.hasNext()) {
    			Person person = (Person) iterator.next();
    			System.out.println("迭代器:"+person);
    		} 	 
            /*  2.增强for循环
             * for(Person p:set){
            	 System.out.println(p);
             }*/
        	  
         }
    
    }
    

    结果:

           迭代器:Person [x=1, y=1]
           迭代器:Person [x=1, y=3]

    所以一定要重写equals()和hashCode()方法


    Set接口有两个子类:HashSet和TreeSet 。
    |-  HashSet
        |-  特点:在不存在重复元素的基础上,还可以进行高速的存取元素。
         |-  要求:需要为您的类重写hashCode()和equals()方法。
    |-  TreeSet
        |-  特点:在不存在重复元素的基础上,还可以将元素自动排序。
         |-  要求:需要为您的类实现Comparable接口,并重写compareTo方法。  
        |-  重写compareTo() 可以同时完成两份工作   排序和消除重复。

    展开全文
  • 《java编程的逻辑》读书笔记 HashMap 主要实例变量: ...transient Entry,V>[] talbe = ...如果要保持添加的顺序,可以使用HashSet的一个子类,LinkedHashSet。Set还有一个重要的 实现类TreeSet,它可以排序。

    《java编程的逻辑》读书笔记

    HashMap

    1. 主要实例变量:

    transient Entry<K,V>[] talbe = (Entry<K,V>[]) EMPTY_TABLE; // 称为哈希表或哈系桶,其中每个元素指向一个单向链表,链表中每个节点表示一个键值对。
    transient int size; // 键值对个数
    int threshold; // 阙值,当键值对个数大于等于threshold时考虑进行扩展
    final float loadFactor; // 负载因子,表示整体上table被占用的成都,是一个浮点数,默认0.75,可以通过构造方法修改

    threshold:
    2. 一般而言,threshold等于table.length乘以loadFactor。如果:table.length = 16, loadFactor = 0.75,则threshold为12。

    1. 扩展策略类似ArrayList,添加第一个元素时,默认分配大小:16,不过并不是size大于16在进行扩展,下册什么时候扩展与threshold有关
    2. HashMap的put方法,先计算key的hash值,然后把hash值进行一些位运算(为了随机和均匀性),拿到key在table中的位置;(不同的hash值进行位运算后位置可能相同,相同位置的元素组成单向链表,链表每个节点表示一个键值对)
      table[i]指向一个单向链表

    小结:

    1. 根据键保存和获取值的效率都很高,为O(1),每个单向链表往往只有一个或少数几个节点,根据hash值就可以直接快速定位;
    2. HashMap中的键值对 没有顺序,因为hash值是随机的

    如果经常需要根据键值存取值,而且不要求顺序,那么HashMap就是理想的选择。如果要保持添加顺序,可以使用HashMap的子类LinkedHashMap。Map还有一个TreeMap实现类,可以排序。

    HashMap不是线程安全的,HashTable是Java最早实现的容器类之一,实现了Map接口,实现原理与HashMap类似,但是没有特别的优化,它内部通过synchronized实现了线程安全。在HashMap中,键和值都可以为null,而在Hashtable中不可以。在不需要并发安全的场景中,推荐使用HashMap。在高并发的场景中,推荐使用ConcurrentHashMap。

    HashSet

    HashSet内部使用HashMap实现的,它内部有一个HashMap实例变量
    private transient HashMap<E,Object> map;
    HashSet相当于只有键,值都是相同的固定值,这个值定义为:
    private static final Object PRESENT = new Object();
    比如add方法:

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

    小结:

    1. 没有重复元素
    2. 可以高效的添加、删除元素、判断元素是否存在,效率都为O(1)
    3. 没有顺序。

    HashSet可以方便高效地实现去重、集合运算等功能。如果要保持添加的顺序,可以使用HashSet的一个子类,LinkedHashSet。Set还有一个重要的 实现类TreeSet,它可以排序。

    展开全文
  • HashSet

    2019-03-14 19:53:29
    与HashMap相同,...HashSet的应用场景: 1、 排重 2、 保存特殊值,比如保存用户黑白名单,来判断用户是否有某权限 3、集合运算,,set可以方便的进行交集,并集等运算 HashSet的内部实现 HashSet内部是用一个...

    与HashMap相同,HashSet也要求元素重写hashCode和equals方法,且对于两个对象如果equals相同,则hashCode也必须相同,如果元素是自定义类,需要注意这一点。
    HashSet的应用场景:
    1、 排重
    2、 保存特殊值,比如保存用户黑白名单,来判断用户是否有某权限
    3、集合运算,,set可以方便的进行交集,并集等运算

    HashSet的内部实现

    HashSet内部是用一个HashMap实现的:

        private transient HashMap<E,Object> map;
    

    HashSet相当于只有键,值都是相同的值:

        // Dummy value to associate with an Object in the backing Map
        private static final Object PRESENT = new Object();
    

    基于这个内部组成,他的实现就很好懂了:

        public HashSet(int initialCapacity, float loadFactor) {
            map = new HashMap<>(initialCapacity, loadFactor);
        }
    
        public HashSet(Collection<? extends E> c) {
            map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
            addAll(c);
        }
    

    c.size()/.75f 用来计算loadFactor的默认值;

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

    add方法就是直接调用map的put方法;

        public boolean contains(Object o) {
            return map.containsKey(o);
        }
    
    

    contains就是直接调用map的containsKey方法

        public boolean remove(Object o) {
            return map.remove(o)==PRESENT;
        }
    
        public Iterator<E> iterator() {
            return map.keySet().iterator();
        }
    
    

    remove和iterator方法也是直接是用的map的方法,简单的超乎想象。

    特点小结:
    1、 没有重复元素
    2、可以高效的添加、删除元素、判断元素是否存在,效率为O(1)
    3、 没有顺序
    如果要保持添加的顺序,可以是用HashSet的子类:LinkedHashSet。Set还有一个重要的实现类TreeSet,他可以进行排序。

    展开全文
  • HashSet<String> set = new HashSet(); Iterator<String> iter = set.iterator(); 2.开始迭代 while (iter.hasNext()) {// 判断迭代器中是否还有元素 String str = iter.next();// 取出一个元素,取出一个,...
    集合框架:Java中预定义的一些数据结构类
    
    集合框架是定义在Java.util包中


    Collection
    |--------List
    |----------LinkedList
    |----------ArrayList
    |----------Vector
    |-----Stack
    |--------Set
    |----------HashSet
    |----------TreeSet
    Map
    |---------HashMap
    |---------TreeMap


    Collection : 表示一组数据的类
    List和Set都继承了Collection
    列表List: 有序的 Collection
    常用的List实现类: (取出元素可以用迭代器和下标)
    ArrayList, LinkedList,Vector 都是List的实现类
    Stack是Vector的子类
    ArrayList 数组序列
    LinkedList 链表
    Stack 栈
    Vector 向量
    集合Set: 无重复的 Collection
    常用的Set实现类: 取出元素用迭代器(没有get方法)
    HashSet()
    TreeSet()

    映射 Map<K,V>
    将键映射到值的一种结构
    键是一个Set,键不能重复
    每一个键都对应一个值
    常用的Map实现类:
    HashMap():键是一个HashSet
    TreeMap():键是一个TreeSet


    *********************************************
    ArrayList:
    数组序列 :有序的,可重复的,长度可变的,有下标的,地址连续的[基于数组]
    优势:因为地址连续, 一旦数据存储好了,查询操作效率比较高
    劣势:插入和删除操作效率比较低 ,不是线程同步的

    add()
    set()
    get() 只是获取
    size()
    remove() 获取并移除
    contains()
    indexof()

    练习:班上有20位同学 ,学号是从1001~1020
    从班上抽出一个一等奖
    两个二等奖
    五个三等奖
    八个安慰奖
    所有获奖的人不能重复

    public class ListDeno2 {
    public static void main(String[] args) {

    ArrayList<Integer> list=new ArrayList<Integer>();
    for(int i=1001;i<=1020;i++){
    list.add(i);
    }
    // 创建随机数对象
    Random rd=new Random();

    //抽取一等奖
    int index=rd.nextInt(list.size());// 随机下标
    // 将抽到的数据移除
    //int n=list.get(index); get()是获取下标为index的元素
    //list.remove(index); remove()是移除下标为index的元素,并返回下标
    int n= list.remove(index);//所以可以直接用remove()
    System.out.println("一等奖是"+"学号为"+n);

    //抽取二等奖
    for(int i=0;i<2;i++){
    int index2=rd.nextInt(list.size());
    int n2=list.remove(index2);
    System.out.println("二等奖是"+"学号为"+n2);
    }
    //抽取一等奖
    for(int i=0;i<5;i++){
    int n3=list.remove(rd.nextInt(list.size()));
    System.out.println("三等奖是"+"学号为"+n3);
    }
    //抽取一等奖
    for(int i=0;i<8;i++){
    int n4=list.remove(rd.nextInt(list.size()));
    System.out.println("安慰奖是"+"学号为"+n4);
    }

    }
    }

    ***************************************************
    LinkedList:链表,链式序列
    有序的,可重复的,长度可变的,有下标的,地址任意的
    地址任意的,各个数据之间通过引用[相当于C语言中的指针]关联
    优势和劣势:
    地址是任意的,适合进行插入和删除的操作
    查询操作性能比较低
    取出元素:
    LinkedList<String> list = new LinkedList<String>();
    方法一:下标
    for(int i=0;i<list.size();i++){
    String str = list.get(i);
    System.out.println(str);
    }
    方法二:poll()方法
    while (!list.isEmpty()) {
    String str = list.poll();
    System.out.println(str);
    }

    数组查询方式:
    int[] t=new int[5];
    创建对象时 开辟了地址连续的内存空间 0x10 0x11 0x12 0x13 0x14
    t -->0x10(t指向内存地址为0x10的存储空间)
    t[0] -->0x10+0
    t[1] -->0x10+1
    t[4] -->0x10+4=0x1014
    所以ArrayList查询操作效率比较高,
    *****************************************************
    Vector:向量
    Vector和 ArrayList一样,都是大小可变的数组的实现
    区别: ArrayList不是同步的
    Vector是同步的,在多线程中一般采用Vector
    使用方式和 ArrayList一样

    stack:栈
    它通过五个操作对类 Vector 进行了扩展
    它提供了通常的 push 和 pop 操作,
    取堆栈顶点的 peek 方法
    测试堆栈是否为空的 empty 方法
    在堆栈中查找项并确定到堆栈顶距离的 search 方法。
    后进先出
    最先放入的数据在栈的底部
    最后放入的数据在栈的顶部
    每次取数据都只能取到栈顶的数据
    ***************************************************
    HashSet() : 无序的,不可重复的,长度可变的
    (如果添加内容不变,则输出顺序不变 因为HashSet()将内容通过哈希算法转化为内存地址,输出是按内存地址大小输出)
    TreeSet():根据内容的自然顺序进行排序
    (如果是字符或字符串,按照ASC码大小输出)
    练习:
    String[] item = {"张三疯","李四光","王二小","张三疯","赵六子",
    "童胖子","周芷若","张无忌","王二小","小昭","周芷若","赵敏","谢逊"};
    去掉数组中重复
    按照名字排序

    public class SetDemo2 {
    public static void main(String[] args) {

    TreeSet<String> set=new TreeSet<String>();

    String[] item = {"a张三疯","李四光","王二小","张三疯","赵六子",
    "童胖子","周芷若","张无忌","王二小","小昭","周芷若","赵敏",
    "谢逊","张无忌","王二小","b小昭","周芷若","赵敏","谢逊"};
    for(int i=0;i<item.length;i++){
    set.add(item[i]);
    }
    Iterator<String> iter=set.iterator();
    while(iter.hasNext()){
    String str=iter.next();
    System.out.println(str);
    }
    // char a='张';
    // char b= '李';
    // char c= '王';
    // System.out.println(a+0);
    // System.out.println(b+0);
    // System.out.println(c+0);


    }
    }


    ******************************************************
    List实现类: 取出元素可以用迭代器和下标
    eg:ArrayList<String> list=new ArrayList<String>();
    //取出元素三种方法:1.使用下标
    for(int i=0;i<list.size();i++){
    String str=list.get(i);
    System.out.println(str);
    }
    //2.使用迭代器
    Iterator<String> iter=list.iterator();
    while(iter.hasNext()){
    String str=iter.next();
    System.out.println(str);
    }
    //3.增强的For循环
    for(String str:list){
    System.out.println(str);
    }
    Set实现类: 取出元素用迭代器(没有get方法)
    eg:
    方法一:
    1.将Set中的数据放入迭代器,并返回该迭代器
    HashSet<String> set = new HashSet<String>();
    Iterator<String> iter = set.iterator();
    2.开始迭代
    while (iter.hasNext()) {// 判断迭代器中是否还有元素
    String str = iter.next();// 取出一个元素,取出一个,迭代器中就少一个
    System.out.println(str);
    }
    方法二:
    增强版的for循环
    for (String str : set) {
    System.out.println(str);
    }
    ********************************************************
    HashMap():k是一个HashSet
    TreeMap():k是一个TreeSet
    所有的K不能重复,每一K都对应一个Value
    如果在加入数据的时候,出现相同的K,则替换掉原有的Value
    取出数据:
    1.取得所有的k
    HashMap<String,Integer> map = new HashMap<String,Integer>();
    Set<String> set = map.keySet();
    2.迭代Set
    Iterator<String> iter = set.iterator();
    while(iter.hasNext()){
    //取得一个K
    String key = iter.next();
    //根据K获得Value
    int value = map.get(key);
    System.out.println(key+" "+value);
    }

    练习:
    String str = "abbcccddddeeeeeffffffggggggg";
    统计这个字符串中每个字符出现的次数
    (提示:Map k:字符 V:次数)

    public class MapDemo {
    public static void main(String[] args) {
    HashMap<Character,Integer> map=new HashMap<Character,Integer>();

    String str = "abbcccddddeeeeeffffffggggggg";
    // 循环取出字符串中的字符
    for(int i=0;i<str.length();i++){
    //根据下标取得字符
    char c=str.charAt(i);

    //将字符放入map
    //判断该字符是否已经存在于map的K中
    boolean b=map.containsKey(c);
    if(b){//如果b为true,则该字符已经出现过
    //如果已经出现过,就先获得该字符已经出现过的次数
    int value= map.get(c);
    value++;
    map.put(c,value) ;
    }else{//如果b为false,这字符是第一次出现
    //如果是第一次出现,就直接放入Map中,次数为1
    map.put(c, 1) ;
    }

    }

    //取出数据
    Set<Character> set=map.keySet();
    Iterator<Character> iter=set.iterator();
    while(iter.hasNext()){
    Character key=iter.next();
    int value=map.get(key);
    System.out.println(key+" "+value);
    }
    }
    }


    ********************************************************
    泛型:在定义类的时候,定义一个不具体的类型,这个类型会在类中的代码中使用到
    在加载类的时候,并没有明确是什么类型
    在创建对象的时候,在指定具体的类型
    如果没有制定具体的类型,则默认采用Object类
    *************************************************************

    总结内容:
    1. ArrayList和LinkedList的区别和使用场景
    ArryList 与linkedList 都实现了List 接口
    ArrayList:实现list接口 采用数组结构保存对象
    优点:便于对集合进行快速的随机访问 查询操作效率比较高
    缺点:插入和删除操作效率比较低
    原因:指定位置索引插入对象时,会同时将此索引位置之后的所有对象相应的向后移动一位。删除会同时向前移动一位。
    linkedList:实现list接口 采用链表结构保存对象
    优点:插入和删除操作效率比较高
    缺点:查询操作效率比较低
    原因:链表结构在插入对象时只需要简单的需该链接位置,省去了移动对象的操作 在查询上LinkedList只能从链表的一端移动到另一端故效率较低
    使用场景:
    ArrayList使用场景:一般顺序遍历情况下使用ArrayList 尽量不对ArrayList进行插入或删除操作(删除尾部除外),若有多次删除/插入操作又有随机遍历的需求,可以再构建一个ArrayList,把复合条件的对象放入新ArrayList,而不要频繁操作原ArrayList

    LinkedList使用场景:经常有删除/插入操作而顺序遍历列表


    2. ArrayList和Vector的区别和使用场景
    相同点:
    ArrayList 和Vector是实现List接口,采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入、删除数据要涉及到数组元素移动等内存操作,所以索引数据快 插入、删除数据慢.
    区别:
    1.Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的,因此ArrayList中的对象并不是线程安全的
    2.ArrayList有3个构造函数,而Vector有4个构造函数。Vector除了包括和ArrayList类似的3个构造函数之外,另外的一个构造函数可以指定容量增加系数。
    3.当你向这两种类型中增加元素的时候,如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度,Vector缺省情况下自动增长原来一倍的数组长度,ArrayList是原来的50%
    使用场景:
    ArrayList使用场景:因为同步的要求会影响执行的效率,所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择,这样可以避免由于同步带来的不必要的性能开销
    Vector使用场景: 如果你要在集合中保存大量的数据那么使用Vector有一些优势,因为你可以通过设置集合的初始化大小来避免不必要的资源开销。


    3. HashSet与TreeSet的使用场景
    HashSet:哈希表是通过使用称为散列法的机制来存储信息的,元素并没有以某种特定顺序来存放
    TreeSet:提供一个使用树结构存储Set接口的实现(红黑树算法),对象以升序顺序存储,访问和遍历的时间很快。
    使用场景:HashSet是基于Hash算法实现的,其性能通常都优于TreeSet。我们通常都应该使用HashSet,在我们需要排序的功能时,我们才使用TreeSet。


    4.HashSet与TreeSet的底层运行方式:
    TreeSet集合对象的加入过程:
    TreeSet的底层是通过二叉树来完成存储的,无序的集合
    当我们将一个对象加入treeset中,treeset会将第一个对象作为根对象,然后调用对象的compareTo方法拿第二个对象和第一个比较,当返回至=0时,说明2个对象内容相等,treeset就不把第二个对象加入集合。返回>1时,说明第二个对象大于第一个对象,将第二个对象放在右边,返回-1时,则将第二个对象放在左边,依次类推

    HashSet集合对象的加入过程:
    hashset底层是hash值的地址,它里面存的对象是无序的。
    第一个对象进入集合时,hashset会调用object类的hashcode根据对象在堆内存里的地址调用对象重写的hashcode计算出一个hash值,然后第一个对象就进入hashset集合中的任意一个位置。
    第二个对象开始进入集合,hashset先根据第二个对象在堆内存的地址调用对象的计算出一个hash值,如果第二个对象和第一个对象在堆内存里的地址是相同的,那么得到的hash值也是相同的,直接返回true,hash得到true后就不把第二个元素加入集合(这段是hash源码程序中的操作)。如果第二个对象和第一个对象在堆内存里地址是不同的,这时hashset类会先调用自己的方法遍历集合中的元素,当遍历到某个元素时,调用对象的equals方法,如果相等,返回true,则说明这两个对象的内容是相同的,hashset得到true后不会把第二个对象加入集合。


    5. HashMap与TreeMap的使用场景
    HashMap通过hashcode对其内容进行快速查找,而 TreeMap中所有的元素都保持着某种固定的顺序,如果你需要得到一个有序的结果你就应该使用TreeMap(HashMap中元素的排列顺序是不固定的)。
    使用场景
    HashMap:适用于在Map中插入、删除和定位元素。
    Treemap:适用于按自然顺序或自定义顺序遍历键(key)
    展开全文
  • HashSet 是一个优化过的无序集合,提供对元素的高速查找和高性能的set集合操作,而且 HashSet 是在 .NET 3.5 中被引入的,在 System.Collection.Generic 命名空间下,这篇就来讨论一下如何使用这个 HashSet。...
  • 1.HashSet和HashMap在高并发场景下也会报java.util.ConcurrentModificationException异常 2.解决办法: Set s= new CopyOnWriteArraySet<>(); private final CopyOnWriteArrayList<E> al; /** * ...
  • hashset踩坑

    2019-08-21 15:26:40
    使用hashset去重: 源码如上,可以看到hashSet的add方法调用的是HashMap的put的方法,而put方法返回的是上一个value值,把这个值是否为空作为方法返回!这样根据add的返回值就可以判断是否重复! 但是每次调用的...
  • import java.util.HashSet; import java.util.Set; import java.util.TreeSet; /* set 里的方法和list相同 * HashSet 无序不可重复 (因为底层实现的是HashMap,hashMap是无序的) * (为什么是不可重复的呢? ...
  • HashSet源码

    2020-02-24 18:56:52
    1、HashSet介绍 与HashMap类似,字面上看,HashSet由两个单词组成:Hash和Set。其中,Set表示接口,实现Set接口也有多种方式,各有特点,HashSet实现的方式利用了Hash Set public interface Set<E> extends ...
  • 关于HashSet

    2018-06-09 14:33:00
    HashSet调用add方法时,有返回值,返回值是boolean类型,表示是否添加成功(如果对象不存在,则添加成功,否则添加失败)但是,添加的过程并不是一个个去遍历去判断是否已存在,这样效率太低(假设一种场景,...
  • java HashSet

    2019-08-22 11:37:38
    HashSet的源码并不长,因为底层是HashMap实现的,而HashMap的key值是不能重复的,可以直接实现Set保存非重复元素的特性 HashSet的变量不多,内部定义了一个HashMap用来保存数据,PRESENT 用来保存HashMap的只,这意味...
  • Java HashSet

    2017-02-28 09:37:16
    容器实现了Set接口,后端由hash table支持.每次在迭代的时候,容器不保证迭代遍历的顺序.可以存储null元素. ...因此,在性能非常重要的场景下,不适合于将HashSet的初始capacity设置的过大或者装载因子过低. 同样
  • 一般用于对健值对方式快速查询的使用场景。但是线程不安全,线程的安全的话可以使用tableMap,但tableMap的锁太重,因此可以使用ConcurretHashMap采取分段锁的方式性能更搞。 HashMap无序,如果要有序遍历的情况可以...
  • C# HashSet集合类型使用介绍

    千次阅读 2016-05-12 19:45:46
    http://blog.csdn.net/scalzdp/article/details/27346427
  • HashSet、LinkedHashSet、TreeSet使用区别

    千次阅读 2013-10-21 18:45:12
    HashSet:哈希表是通过使用称为散列法的机制来存储信息的,元素并没有以某种特定顺序来存放; LinkedHashSet:以元素插入的顺序来维护集合的链接表,允许以插入的顺序在集合中迭代; TreeSet:提供一个使用树结构...
  • 深度剖析HashSet

    万次阅读 2020-12-05 13:02:29
    HashSet是Java集合Set的一个实现类,Set是一个接口,其实现类除HashSet之外,还有TreeSet,并继承了Collection,HashSet集合很常用,同时也是程序员面试时经常会被问到的知识点 我就没见过这么不要脸的数据结构,...
  • 应用场景:数据去重复 Application:Data removal duplication 继承关系:HashSet继承于AbstractSet,AbstractSet继承于AbstractCollection实现了Set,克隆,有序化接口. Extend relationship:HashSet extends ...
  • HashSet源码分析

    2011-12-03 10:39:03
    HashSet是Set的一个实现,Set定义一个集合,集合的一个特征是不能包含重复的元素(可以包含null),HashSet底层使用HashMap作为存储结构来实现。    可知HashSet只用来存储对象,并不是key-value对,因为HashMap中...
  • HashSet学习笔记

    2021-08-09 21:48:08
    文章目录tips构造方法迭代器方法 tips HashSet是依赖于HashMap的一种Set接口的实现。不能保证在对set进行迭代时的顺序,...当再多线程场景使用时,建议在创建对象时使用以下方法: Set s = Collections.synchroni
  • HashSet:实现了Set接口的一个类。 90、 关于 Object 类的 equals 方法的特点 a) 自反性:x.equals(x)应该返回 true b) 对称性:x.equals(y)为 true,那么 y.equals(x)也为 true。 c) 传递性:x.equals(y)为...
  • HashSet基本操作

    2019-09-18 00:04:46
    ** 1.HashSet的添加时的...**1.1 **重要:需要去重的对象必须做到覆盖Object的equals和hashcode方法,具体实现需要根据业务场景来定. **1.2 **HashSet 会首先调用 obj 的 hasCode 方法得到该对象的哈希码,HashSet 会...
  • Java集合之HashSet

    2017-08-04 14:58:14
    HashSet
  • HashSet 存储结构,应用场景,实现原理
  • HashSet 源码解析

    2018-01-08 00:22:27
    HashSet ,是在HashMap的基础之上保持这一特性,并且拥有自身的特点(如果对于HashMap忘了,或者不了解,可以先了解HashMap , 否则,是无法准确地了解HashSet的原理。所以此篇文章是基于了解一些HashMap特性的) ...
  • Java HashSet用法详解

    2020-09-07 10:35:17
    HashSet基于HashMap来实现的,是一个不允许有...HashSet类位于java.util包中,使用前需要引入它,语法格式如下: import java.util.HashSet;//引入HashSetHashSet的创建及常用操作如下: //引入HashSet类 im
  • 之所以把HashSet和HashMap放在一起讲解,是因为二者在Java里有着相同的实现,前者仅仅是对后者做了一层包装,也就是说HashSet里面有一个HashMap(适配器模式)。因此本文将重点分析HashMap。 HashMap实现了Map...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,032
精华内容 13,612
关键字:

hashset的使用场景