HashSet，LinkedHashSet详解

于 2024-08-10 22:45:05 发布
阅读量624 收藏 20
点赞数 14
分类专栏： 集合 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ADCvbV/article/details/141097395
版权

一.集合体系结构：

二.Set系列集合：（注：Set是接口，不能实例化，只能创建实现类的对象）

1.特点：

  • 无序：存和取的顺序有可能不一致:

    例如：

    package com.itheima.a06mySet;
​
import java.util.HashSet;
import java.util.Set;
​
public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();
​
        //2.添加元素
        /* 如果当前元素是第一次添加，那么可以添加成功，返回true
           如果当前元素是第二次添加，那么添加失败，返回false
           添加失败的元素在遍历集合时不会出现
         */
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");
​
        //3.打印集合
         //Set集合有无序性，先存的张三，但打印时先出的李四
        System.out.println(s);//[李四, 张三, 王五]
​
    }
}
​

  • 不重复：集合中的元素不能重复-->可用于数据的去重：

    例如：

    package com.itheima.a06mySet;

import java.util.HashSet;
import java.util.Set;

public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();

        //2.添加元素
        /* 如果当前元素是第一次添加，那么可以添加成功，返回true
           如果当前元素是第二次添加，那么添加失败，返回false
           添加失败的元素在遍历集合时不会出现
         */
        boolean b1=s.add("张三");
        boolean b2=s.add("张三");
        boolean b3=s.add("王五");

        //3.打印集合
        System.out.println(b1);//true
        System.out.println(b2);//false
        System.out.println(b3);//true
        System.out.println(s);//[张三, 王五]

    }
}

  • 无索引：没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素；

2.Set集合的实现类：

  • HashSet：无序，不重复，无索引

  • LinkedHashSet：有序，不重复，无索引

  • TreeSet：可排序，不重复，无索引

3.Set接口中的方法基本上与Collection的API一致：

1)Collection中的方法：

2)遍历字符串练习：

存储字符串并遍历：利用Set系列的集合，添加字符串，并使用多种方式遍历。

  • 迭代器

    例如：

    package com.itheima.a06mySet;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();

        //2.添加元素
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");

        //3.打印集合
        Iterator<String> it=s.iterator();
        while (it.hasNext()){
            String str= it.next();
            System.out.print(str+"，");
        }

        //运行结果为李四，张三，王五，

    }
}

  • 增强for

    例如：

    package com.itheima.a06mySet;

import java.util.HashSet;
import java.util.Set;

public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();

        //2.添加元素
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");

        //3.打印集合
        for (String str : s) {
            System.out.print(str+",");
        }

        //运行结果为李四,张三,王五,

    }
}

    ​

  • Lambda表达式

    例如：未改写为Lambda表达式前：

    package com.itheima.a06mySet;

import java.util.HashSet;
import java.util.Set;
import java.util.function.Consumer;

public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();

        //2.添加元素
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");

        //3.打印集合
        s.forEach(new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.print(str+"，");
            }
        });

        //运行结果为李四，张三，王五，

    }
}

    改写为Lambda表达式后：

    package com.itheima.a06mySet;

import java.util.HashSet;
import java.util.Set;

public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();

        //2.添加元素
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");

        //3.打印集合
        s.forEach((String str) -> {
                System.out.print(str+"，");
            }
        );

        //运行结果为李四，张三，王五，

    }
}

  • 简化Lambda表达式：

package com.itheima.a06mySet;

import java.util.HashSet;
import java.util.Set;

public class A01_SetDemo1 {
    public static void main(String[] args) {
        //1.创建一个Set集合的对象
        Set<String> s=new HashSet<>();

        //2.添加元素
        s.add("张三");
        s.add("张三");
        s.add("李四");
        s.add("王五");

        //3.打印集合
        s.forEach( str ->
                System.out.print(str+"，")
        );

        //运行结果为李四，张三，王五，

    }
}

 

 

三.HashSet底层原理：
 

1.HashSet集合底层采取哈希表存储数据。
 

2.哈希表是一种对于增删改查数据性能都较好的数据结构。
 

a.哈希表组成：
 

  •  
    JDK8之前：数组 + 链表
     
  •  
    JDK8开始： 数组 + 链表 + 红黑树
     
 

b.哈希值：
 

 

例1：如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
 

对象Student:
 

package com.itheima.a06mySet;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
 

测试类：
 

package com.itheima.a06mySet;

public class A02_HashSetDemo1 {
    public static void main(String[] args) {
        //1.创建对象
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("zhangsan",23);

        //2.如果没有重写hashCode方法，不同对象计算出的哈希值是不同的
        System.out.println(s1.hashCode());//运行结果为793589513
        System.out.println(s2.hashCode());//运行结果为1313922862
    }
}

 

​

 

例2：如果已经重写hashCode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
 

对象Student:
 

package com.itheima.a06mySet;

import java.util.Objects;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
 

测试类：
 

package com.itheima.a06mySet;

public class A02_HashSetDemo1 {
    public static void main(String[] args) {
        //1.创建对象
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("zhangsan",23);

        //2.如果已经重写hashCode方法，不同的对象只要属性值相同，计算出的哈希值就是一样的
        System.out.println(s1.hashCode());//运行结果为-1461067292
        System.out.println(s2.hashCode());//运行结果为-1461067292
    }
}

 

​
 

 

例3：在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样（哈希碰撞）
 

package com.itheima.a06mySet;

public class A02_HashSetDemo1 {
    public static void main(String[] args) {
        //在小部分情况下，不同的属性值或者不同的地址值计算出来的哈希值也有可能一样
        //哈希碰撞
        System.out.println("abc".hashCode());//运行结果为96354
        System.out.println("acD".hashCode());//运行结果为96354
    }
}

 

​
 

3.HashSet在JDK8的底层原理：
 

 

 

上述两个方法不重写的话在底层就利用的是地址值，意义不大。
 

 

 

四.HashSet的三个问题：
 

问题1：HashSet为什么存和取的顺序可能不一样？和遍历有关，具体看b站视频（黑马程序员Java上，阿伟的）。
 

问题2：HashSet为什么没有索引？因为HashSet不纯粹，有链表，红黑树和数组，带索引没 意义。
 

问题3：HashSet是利用什么机制保证数据去重的？利用HashCode方法（可得到哈希值，哈希值可确定当前元素添加在数组中的位置）和equals方法（比较对象内部的属性值是否相同）
 

 

 

五.HashSet集合练习：利用HashSet集合去除重复元素(不去重一般用ArrayList集合)
 

1.注：一定要重写HashCode和equals方法，不重写的话会操作地址值，地址值大多都不一样，很难做到去重
 

如：Student类：
 

package com.itheima.a06mySet;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
 

测试类：
 

package com.itheima.a06mySet;

import java.util.HashSet;

public class A03_HashSetDemo2 {
    public static void main(String[] args) {
        /* 需求：创建一个存储学生对象的集合，存储多个学生对象。
            使用程序实现在控制台遍历该集合。
           要求：学生对象的成员变量值相同，我们就认为是同一个对象。
         */

        //1.创建学生对象
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("lisi",24);
        Student s3=new Student("wangwu",25);
        Student s4=new Student("zhangsan",23);

        //2.创建集合用来添加学生
        HashSet<Student> hs=new HashSet<>();

        //3.添加元素
        System.out.println(hs.add(s1));//运行结果为true
        System.out.println(hs.add(s2));//运行结果为true
        System.out.println(hs.add(s3));//运行结果为true
        System.out.println(hs.add(s4));//运行结果为true

        //4.打印集合
        System.out.println(hs);
         /*运行结果为[Student{name = wangwu, age = 25}, Student{name = zhangsan, age = 23},
                    Student{name = lisi, age = 24}, Student{name = zhangsan, age = 23}]
          */
    }
}
 

本例中没有重写HashCode方法和equals方法，此时操作地址值，导致难以做到去重。因此，对象s1和对象s4即使属性值一样，但地址值不同，因此可以添加，但没做到去重。
 

 

 

2.重写HashCode方法和equals方法后即可做到去重：
 

如：Student类：
 

package com.itheima.a06mySet;

import java.util.Objects;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
 

 

测试类：
 

package com.itheima.a06mySet;

import java.util.HashSet;

public class A03_HashSetDemo2 {
    public static void main(String[] args) {
        /* 需求：创建一个存储学生对象的集合，存储多个学生对象。
            使用程序实现在控制台遍历该集合。
           要求：学生对象的成员变量值相同，我们就认为是同一个对象。
         */

        //1.创建学生对象
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("lisi",24);
        Student s3=new Student("wangwu",25);
        Student s4=new Student("zhangsan",23);

        //2.创建集合用来添加学生
        HashSet<Student> hs=new HashSet<>();

        //3.添加元素
        System.out.println(hs.add(s1));//运行结果为true
        System.out.println(hs.add(s2));//运行结果为true
        System.out.println(hs.add(s3));//运行结果为true
        System.out.println(hs.add(s4));//运行结果为false

        //4.打印集合
        System.out.println(hs);
         /*运行结果为[Student{name = wangwu, age = 25}, Student{name = lisi, age = 24},
                    Student{name = zhangsan, age = 23}]
          */
    }
}
 

​
 

3.注：String类型和Integer类型等的数据，此时不需要手动重写HashCode方法和equals方法就能做到去重，因为Java已经写好了。
 

 

 

六.LinkedHashSet底层原理：具体看b站视频（黑马程序员Java上，阿伟的）
 

 

代码举例：
 

Student类：
 

package com.itheima.a06mySet;

import java.util.Objects;

public class Student {
    private String name;
    private int age;


    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     *
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     *
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     *
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     *
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}
 

测试类：
 

package com.itheima.a06mySet;

import java.util.LinkedHashSet;

public class A04_LinkedHashSetDemo {
    public static void main(String[] args) {
        //1.创建4个学生对象
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("lisi",24);
        Student s3=new Student("wangwu",25);
        Student s4=new Student("zhangsan",23);

        //2.创建集合的对象
        LinkedHashSet<Student> lhs=new LinkedHashSet<>();

        //3.添加元素
        System.out.println(lhs.add(s1));//运行结果为true
        System.out.println(lhs.add(s2));//运行结果为true
        System.out.println(lhs.add(s3));//运行结果为true
        System.out.println(lhs.add(s4));//运行结果为false

        //4.打印集合
        System.out.println(lhs);
        /*运行结果为[Student{name = zhangsan, age = 23}, Student{name = lisi, age = 24},
                   Student{name = wangwu, age = 25}]
         */
        //注：此时存和取的顺序是一致的,先存入的s1,取的时候也就先取s1,以此类推
    }
}
 

 

 

七.总结：
 

 

LinkedHashSet集合比HashSet集合效率低，因为LinkedHashSet集合在哈希表的基础上又多做了一些事(操作数据顺序)。
 


                

        

        

    

  


    

      

        

            

              
                
                  扫弦欲止音
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Java—Set集合详解（HashSet/LinkedHashSet/TreeSet/EnumSet）

				
			

			

				

					12-21
				

			

		

		

			
				
本文将深入探讨Java中四个主要的Set实现类：HashSet、LinkedHashSet、TreeSet以及EnumSet。  首先，Set集合的核心特性是不存储重复元素。在尝试通过`add()`方法添加相同元素时，如果集合中已经存在该元素，`add()`...

			
		

	



                

              
                



	

		

			

				
					
【Java集合系列四】HashSet和LinkedHashSet解析

				
			

			

				

					weixin_30271335的博客
				

				

					07-29
					
					453
					
				

			

		

		

			
				
2017-07-2916:58:13
一、简介
1、Set概念
Set可以理解为集合，非常类似数据概念中的集合，集合三大特征：1、确定性；2、互异性；3、无序性，因此Set实现类也有类似的特征。
2、HashSet
HashSet继承自AbstractSet，实现了Set接口，但是其源码非常少，也非常简单。内部使用HashMap来存储数据，数据存储在HashMap的key中，value...

			
		

	



                


  
              

                


	

		

			

				
					
HashSet 和 Linked

				
			

			

				

					mx9853的博客
				

				

					11-18
					
					126
					
				

			

		

		

			
				
一、继承关系：
public class HashSet&lt;E&gt;
    extends AbstractSet&lt;E&gt;
    implements Set&lt;E&gt;, Cloneable, java.io.Serializable
    可克隆，可序列化
二、特点：基于HashMap实现的HashSet   存放单一值key值
key值只有一个可以为null  k...

			
		

	





	

		

			

				
					
HashSet和LinkedHashSet

				
			

			

				

					weixin_47382783的博客
				

				

					07-27
					
					1940
					
				

			

		

		

			
				
HashSet是Set接口的子类，其内部采用了HashMap作为数据存储，HashSet其实就是在操作HashMap的key。HashSet是无序存储的，不能保证元素的顺序；HashSet并没有进行同步处理，因此是线程不安全的；HashSet可以存储null元素，但只能存储一个。（1）基于HashMap实现的，默认构造函数是构建一个初始容量为16，负载因子为0.75的HashMap。httpshttps。......

			
		

	



		

			
		



	

		

			

				
					
3-2、集合之 Set 细品 HashSet 、LinkHashSet、TreeSet

				
			

			

				

					众纳百川的博客
				

				

					05-28
					
					167
					
				

			

		

		

			
				
前面我已经提到了List 是一个有序集合，可以允许重复，而今天要研究的Set 是无序集合，不允许重复；
Set 分别被HashSet、TreeSet、LinkHashSet继承。
本文以HashSet 举例 介绍Set的用法
快速进入关于List 的文章
不可重复测试
		Set<String> s=new HashSet<>();
        s.add("a");
        s.add("b");
        s.add("c");
        s.add("c

			
		

	





	

		

			

				
					
LinkHashSet 和 HashSet的区别：

				
			

			

				

					m0_52646273的博客
				

				

					05-14
					
					519
					
				

			

		

		

			
				
package day03.ListDemo.HashCodeDemo;

import java.util.HashSet;
import java.util.LinkedHashSet;

/*
    LinkHashSet 和 HashSet的区别：
    Java.util.LinkHashSet集合 extends HashSet集合
    LinkHashSet底层是一个哈希表（数组+红黑树/链表）+链表：
    多了一条链表（记录元素的存储顺序），保证元素存取有序
*/
public 

			
		

	





	

		

			

				
					
Java中的HashSet与LinkedHashSet详解

				
			

			

				

					
				

			

		

		

			
				
"HashSet和LinkedHashSet是Java集合框架中两种重要的Set接口实现。HashSet是一个基于哈希表的集合，不保证元素顺序，而LinkedHashSet则在保持元素插入顺序的基础上提供了哈希表的功能。"  HashSet的使用和特点: ...

			
		

	





	

		

			

				
					
Java HashSet类详解与示例

				
			

			

				

					
				

			

		

		

			
				
HashSet类的用法  HashSet是Java集合框架中的一员，它实现了Set接口，主要用来存储不重复的元素。这个类的特点如下：  1. **无序性**：HashSet内部并不保证元素的顺序，...在需要有序集合时，可以选择LinkedHashSet类。

			
		

	





	

		

			

				
					
Java集合框架深度解析：LinkedHashSet详解

				
			

			

				

					
				

			

		

		

			
				
"这篇文档主要介绍了Java集合框架中的LinkedHashSet类，它是一个特殊的HashSet实现，保持了元素的插入顺序，并且具有常数时间复杂度的基本操作。此外，集合框架的性能受到初始容量和加载因子的影响。文档还涵盖了...

			
		

	





	

		

			

				
					
Java Set集合深入解析：HashSet、LinkedHashSet、TreeSet、EnumSet

				
			

			

				

					
				

			

		

		

			
				
HashSet类详解： HashSet是最基础的Set实现，它依赖于HashMap来存储元素。由于基于哈希表，HashSet提供了快速的查找和添加操作。元素可以为null，但不保证元素的顺序，这意味着每次遍历HashSet时，元素的顺序可能...

			
		

	





	

		

			

				
					
关于HashSet与LinkedHashSet

				
			

			

				

					syl2850246的博客
				

				

					03-05
					
					160
					
				

			

		

		

			
				
HashSet原理：
我们使用Set集合都是需要去掉重复元素的，如果在存储的时候逐个equals()比较，效率较低，哈希算法提高了去重复的效率，降低了使用equals()方法的次数
当HashSet调用add()方法存储对象的时候，先调用对象的HashCode()方法得到一个哈希值，然后在集合中查找是否有哈希值
相同的对象
如果没有哈希值，相同的对象就直接存入集合
如果有哈希值相同的对象，就和哈希...

			
		

	





	

		

			

				
					
hashset和Linkedset的区别与联系

				
			

			

				

					chouhong7839的博客
				

				

					03-23
					
					760
					
				

			

		

		

			
				
一.HashSet 特点： 
1.HashSet中不能有相同的元素，可以有一个Null元素，存入的元素是无序的。 
2.HashSet如何保证唯一性？ 
1).HashSet底层数据结构是哈希表，哈希表就是存储唯一系列的表，而哈希值是由对象的hashCode()方法生成。 
2).确保唯一性的...

			
		

	





	

		

			

				
					
Java集合之Set集合（HashSet、TreeSet和 LinkHashSet）详细介绍

				
			

			

				

					JavaWebEngineer的博客
				

				

					07-15
					
					627
					
				

			

		

		

			
				
简介

Set 注重独一无二的性质,该体系集合用于存储无序(存入和取出的顺序不一定相同)元素，值不能重复。
对象的相等性本质是对象 hashCode 值（java 是依据对象的内存地址计算出的此序号）判断的，如果想要让两个不同的对象视为相等的，就必须覆盖 Object 的 hashCode 方法和 equals 方法。
Java Set 一共三个实现类：分别是 HashSet、TreeSet和 LinkHashSet


1、HashSet （Hash 表 ）
哈希表边存放的是哈希值。HashSet 存储元

			
		

	





	

		

			

				
					
LinkedHashSet详解

					
热门推荐

				
			

			

				

					Chenhui98的博客
				

				

					08-30
					
					1万+
					
				

			

		

		

			
				
LInkedHashSet这个容器不知道大家在平时的工作用的多吗，反正我基本上没有用过，所以，本文主要对于它的特点、使用场景、实现原理，做一个讲解，希望对大家平时的工作有所帮助。LinkedHashSet是一个基于LinkedHashMap实现的有序去重集合列表。LinkedHashSet中的元素没有重复LinkedHashSet中的元素有顺序，维护了添加顺序LInkedHashSet可以存储null值LinkedHashSet是一个线程不安全的容器。...

			
		

	





	

		

			

				
					
38-LinkedHashSet集合

				
			

			

				

					shwjakak的博客
				

				

					10-13
					
					164
					
				

			

		

		

			
				
1.LinkedHashSet是HashSet的子类继承了HashSet

此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。


java.util.LinkHashSet 集合extends继承 HashSet集合
LinkHashSet集合特点
1.底层是一个哈希表（数组＋链表/红黑树）+链表 （多的链表用来记录元素的存储顺序）
LinkHashSet集合可以保证元素有序




.

			
		

	





	

		

			

				
					
LinkedHashSet集合底层源码解析

				
			

			

				

					无奈朝来寒雨晚来风 的博客
				

				

					03-20
					
					744
					
				

			

		

		

			
				
提示：发文三个工作日后这里做全文总结提示：以下是本篇文章正文内容，下面案例可供参考LinkedHashSet是HashSet的实现子类，HashSet是数组加单向链表，LinkedHashSet是数组加双向链表，但是LinkedHashSet底层是一个LinkedHashMap。HashSet存入数据顺序和取出的顺序不一样，但每次遍历取出元素的顺序都是一样的。而LinkedHashSet存入和取出的顺序都是一样的。

			
		

	





	

		

			

				
					
Java集合（七）LinkedHashSet

				
			

			

				

					超级程序诞生的博客
				

				

					02-01
					
					2043
					
				

			

		

		

			
				
添加第一次时，直接将数组table扩容到16，存放的结点类型是LinkedHashMap$Entry，table是HashMap$Node内部类数组的这样子一个类型，但是他里面存放的真实的元素是LinkedHashMap$Entry这种类型，他们之间有继承或者实现关系，Entry继承或者实现了Node。（3）在添加一个元素时，先求hash值，在求索引，确定该元素在table的位置，然后将添加的元素加入到双向链表（如果已经存在，不添加【原则和hashset一样】）我们还可以进行查看head和tail。

			
		

	





	

		

			

				
					
HashSet 和LinkHashSet 底层原理

					
最新发布

				
			

			

				

					lohath的博客
				

				

					01-15
					
					477
					
				

			

		

		

			
				
HashSet 和LinkHashSet 底层原理

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值