Set集合

无情 阅读:182 2022-06-06 14:06:18 评论:0

Set集合

java.util.Set接口和java.util.List接口一样,同样继承自Collection接口,它与Collection接口中的方法基本一致,并没有对Collection接口进行功能上的扩充,只是比Collection接口更加严格了。与List接口不同的是,Set接口中元素无序,并且都会以某种规则保证存入的元素不出现重复。

Set集合有多个子类,这里我们介绍其中的java.util.HashSetjava.util.LinkedHashSet这两个集合。

tips:Set集合取出元素的方式可以采用:迭代器、增强for。

HashSet集合介绍

java.util.HashSetSet接口的一个实现类,它所存储的元素是不可重复的,并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持,由于我们暂时还未学习,先做了解。

HashSet是根据对象的哈希值来确定元素在集合中的存储位置,因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于:hashCodeequals方法。

我们先来使用一下Set集合存储,看下现象,再进行原理的讲解:

public class HashSetDemo {
   
     
    public static void main(String[] args) {
   
     
        //创建 Set集合 
        HashSet<String>  set = new HashSet<String>(); 
 
        //添加元素 
        set.add(new String("cba")); 
        set.add("abc"); 
        set.add("bac");  
        set.add("cba");   
        //遍历 
        for (String name : set) {
   
     
            System.out.println(name); 
        } 
    } 
} 

输出结果如下,说明集合中不能存储重复元素:

cba 
abc 
bac 

tips:根据结果我们发现字符串"cba"只存储了一个,也就是说重复的元素set集合不存储。

HashSet集合存储数据的结构(哈希表)

什么是哈希表呢?

JDK1.8之前,哈希表底层采用数组+链表实现,即使用链表处理冲突,同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多,即hash值相等的元素较多时,通过key值依次查找的效率较低。而JDK1.8中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间。

简单的来说,哈希表是由数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的,如下图所示。

image-20210204163917193

image-20210204173032450

看到这张图就有人要问了,这个是怎么存储的呢?

为了方便大家的理解我们结合一个存储流程图来说明一下:

image-20210204164010260

image-20210204174258689

总而言之,JDK1.8引入红黑树大程度优化了HashMap的性能,那么对于我们来讲保证HashSet集合元素的唯一,其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象,那么保证其唯一,就必须复写hashCode和equals方法建立属于当前对象的比较方式。

HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的比较方式,才能保证HashSet集合中的对象唯一

创建自定义Student类

public class Student {
   
     
    private String name; 
    private int age; 
 
    public Student() {
   
     
    } 
 
    public Student(String name, int age) {
   
     
        this.name = name; 
        this.age = age; 
    } 
 
    public String getName() {
   
     
        return name; 
    } 
 
    public void setName(String name) {
   
     
        this.name = name; 
    } 
 
    public int getAge() {
   
     
        return 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 class HashSetDemo2 {
   
     
    public static void main(String[] args) {
   
     
        //创建集合对象   该集合中存储 Student类型对象 
        HashSet<Student> stuSet = new HashSet<Student>(); 
        //存储  
        Student stu = new Student("于谦", 43); 
        stuSet.add(stu); 
        stuSet.add(new Student("郭德纲", 44)); 
        stuSet.add(new Student("于谦", 43)); 
        stuSet.add(new Student("郭麒麟", 23)); 
        stuSet.add(stu); 
 
        for (Student stu2 : stuSet) {
   
     
            System.out.println(stu2); 
        } 
    } 
} 
执行结果: 
Student [name=郭德纲, age=44] 
Student [name=于谦, age=43] 
Student [name=郭麒麟, age=23] 

LinkedHashSet

我们知道HashSet保证元素唯一,可是元素存放进去是没有顺序的,那么我们要保证有序,怎么办呢?

在HashSet下面有一个子类java.util.LinkedHashSet,它是链表和哈希表组合的一个数据存储结构。

演示代码如下:

public class LinkedHashSetDemo {
   
     
	public static void main(String[] args) {
   
     
		Set<String> set = new LinkedHashSet<String>(); 
		set.add("bbb"); 
		set.add("aaa"); 
		set.add("abc"); 
		set.add("bbc"); 
        Iterator<String> it = set.iterator(); 
		while (it.hasNext()) {
   
     
			System.out.println(it.next()); 
		} 
	} 
} 
结果: 
  bbb 
  aaa 
  abc 
  bbc 

可变参数

JDK1.5之后,如果我们定义一个方法需要接受多个参数,并且多个参数类型一致,我们可以对其简化成如下格式:

修饰符 返回值类型 方法名(参数类型... 形参名){  } 

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  } 

只是后面这种定义,在调用时必须传递数组,而前者可以直接传递数据即可。

JDK1.5以后。出现了简化操作。 用在参数上,称之为可变参数。

同样是代表数组,但是在调用这个带有可变参数的方法时,不用创建数组(这就是简单之处),直接将数组中的元素作为实际参数进行传递,其实编译成的class文件,将这些元素先封装到一个数组中,在进行传递。这些动作都在编译.class文件时,自动完成了。

代码演示:

public class ChangeArgs {
   
     
    public static void main(String[] args) {
   
     
        int[] arr = {
   
     1, 4, 62, 431, 2 }; 
        int sum = getSum(arr); 
        System.out.println(sum); 
        //  6  7  2 12 2121 
        // 求 这几个元素和 6  7  2 12 2121 
        int sum2 = getSum(6, 7, 2, 12, 2121); 
        System.out.println(sum2); 
    } 
 
    /* 
     * 完成数组  所有元素的求和 原始写法 
      
      public static int getSum(int[] arr){ 
        int sum = 0; 
        for(int a : arr){ 
            sum += a; 
        } 
         
        return sum; 
      } 
    */ 
    //可变参数写法 
    public static int getSum(int... arr) {
   
     
        int sum = 0; 
        for (int a : arr) {
   
     
            sum += a; 
        } 
        return sum; 
    } 
} 

tips: 上述add方法在同一个类中,只能存在一个。因为会发生调用的不确定性

注意:如果在方法书写时,这个方法拥有多参数,参数中包含可变参数,可变参数一定要写在参数列表的末尾位置。


标签:java
声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

搜索
排行榜
关注我们

一个IT知识分享的公众号