AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Set集合详解

2023-10-25 64
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Set集合详解

一.set简介

在Java中，Set是一个接口，用于存储一组不重复的元素。Set接口继承自Collection接口，因此它具有Collection接口定义的所有方法，例如添加、删除和迭代等。

1.Set不存储重复的元素

2.Set中的元素通常是无序的

package com.ctb.set;
import java.util.HashSet;
import java.util.Set;
/**
 * set集合的特点 
 * 1.无序-没有下标--所以无法修改 
 * 2.元素无重复
 * 
 * @author biao
 *
 */
public class Demo1 {
  public static void main(String[] args) {
    //定义set集合
    Set set=new HashSet<>();
    //增加
    set.add("ha");
    set.add("ds");
    set.add("dh");
    set.add("es");
    set.add("di");
    //删除
    set.remove("di");
System.out.println(set.size()); //输出：4
    //查询
    System.out.println(set);//输出[dh, ha, es, ds]
  }
}

三.set集合的遍历方式

1.foreach遍历

2.iterator迭代器遍历

package com.ctb.set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
 * set集合的遍历方式
 * 1.foreach遍历
 * 2.iterator迭代器遍历
 * @author biao
 *
 */
public class Demo2 {
  public static void main(String[] args) {
    //定义set集合
        Set set=new HashSet<>();
        //增加
        set.add("花花");
        set.add("曹操");
        set.add("苹果");
        //foreach遍历
        for (Object object : set) {
          System.out.println(object);//输出：花花 苹果 曹操
        }
        System.out.println("------------------------------------");
        //iterator迭代器遍历
        Iterator it = set.iterator();
        while (it.hasNext()) {
          System.out.println(it.next());//输出：花花 苹果 曹操
        }
  }
}

四.HashSet哈希表存储，重复元素存储底层原理

Set集合中元素是不重复的，但在我们存储对象过程中，对象是可以重复添加的，那么，我们 需要重写存储对象中的hashcode方法和equals方法，它会在hashCode方法中进行筛选，再到equals方法进行判断

注：若只重写一个方法，则无法避免存储对象重复的添加

package com.ctb.set;
import java.util.HashSet;
import java.util.Set;
/**
 * set集合对象去重底层原理
 * 先进入hashcode方法进行筛选，后进入equlas方法判断
 * @author biao
 *
 */
public class Demo3 {
  public static void main(String[] args) {
    Set set = new HashSet<>();
    set.add(new Cat(1, "土猫"));
    set.add(new Cat(2, "哈士奇"));
    set.add(new Cat(3, "翔子猫"));
    set.add(new Cat(4, "毛猫"));
    // System.out.println(set.contains(new Cat(2, "哈士奇")));//false
    set.add(new Cat(2, "哈士奇"));
    for (Object object : set) {
      System.out.println(object); //输出结果：Cat [id=4, name=毛猫]
                                 // Cat [id=3, name=翔子猫]
                                // Cat [id=1, name=土猫]
                   // Cat [id=2, name=哈士奇]
    }
  }
}
class Cat {
  private int id;
  private String name;
  public Cat() {
    // TODO Auto-generated constructor stub
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "Cat [id=" + id + ", name=" + name + "]";
  }
  public Cat(int id, String name) {
    super();
    this.id = id;
    this.name = name;
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + id;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    Cat other = (Cat) obj;
    if (id != other.id)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
}

五.LinkedHashSet保留元素插入顺序

LinkedHashSet是基于链表和哈希表的实现，它保留了元素插入的顺序，通过哈希表来实现元素的快速查找。

package com.ctb.set;
import java.util.LinkedHashSet;
import java.util.Set;
/**
 * LinkedHashSet
 * 元素插入排序
 * @author biao
 *
 */
public class Demo5 {
  public static void main(String[] args) {
    Set set = new LinkedHashSet<>();
    set.add("花花");
    set.add("鸟鸟");
    set.add("猫猫");
    set.add("哈哈");
    for (Object object : set) {
      System.out.println(object);// 输出：花花 鸟鸟 猫猫 哈哈
    }
  }
}

六.TreeSet(自然排序，比较器排序)

1.默认排序：set集合中的默认的排序

2.自然排序：实现java.lang.Comparable接口

3.比较器排序：实现java.util.Comparator的匿名内部类

package com.ctb.set;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
/**
 * set集合排序
 * @author biao
 *
 */
public class Demo4 {
  public static void main(String[] args) {
    Set set =new TreeSet<>();
    set.add(new Cart(1, "麻辣", 19));
    set.add(new Cart(2, "香甜", 32));
    set.add(new Cart(3, "可口", 23));
    set.add(new Cart(4, "酸辣", 45));
    set.add(new Cart(5, "苦逼", 23));
    set.add(new Cart(6, "咸蛋", 23));
    System.out.println("-------set集合默认排序---------");
    //默认排序
    for (Object object : set) {
      System.out.println(object);
    }
    //自然排序
    Set ts=new TreeSet<>();
    //添加数据
    for (Object object : set) {
      ts.add(object);
    }
    System.out.println("------java.lang.Comparable自然排序-------");
    for (Object object : ts) {
      System.out.println(object);
    }
    //比较排序--根据价格排序
    Set s=new TreeSet<>(new Comparator<Cart>() {
      @Override
      public int compare(Cart o1, Cart o2) {
        // TODO Auto-generated method stub
        return o2.getPrice()-o1.getPrice();
      }
    });
    //添加数据
    for (Object object : set) {
      s.add(object);
    }
    System.out.println("---------java.util.Comparator的匿名内部类-按价格排序--------");
    for (Object object : s) {
      System.out.println(object);
    }
    //比较排序--先根据价格排序--价格相同则按id排序
        Set ss=new TreeSet<>(new Comparator<Cart>() {
          @Override
          public int compare(Cart o1, Cart o2) {
            // TODO Auto-generated method stub
            int n=o2.getPrice()-o1.getPrice();
            if (n==0) {
              return o1.getId()-o2.getId();
            }
            return n;
          }
        });
        //添加数据
        for (Object object : set) {
          ss.add(object);
        }
        System.out.println("---------java.util.Comparator的匿名内部类-先价格，再id排序--------");
        for (Object object : ss) {
          System.out.println(object);
        }
  }
}
class Cart implements Comparable<Cart>{
  private int id;
  private String name;
  private int price;
  public Cart() {
    // TODO Auto-generated constructor stub
  }
  @Override
  public String toString() {
    return "Cart [id=" + id + ", name=" + name + ", price=" + price + "]";
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getPrice() {
    return price;
  }
  public void setPrice(int price) {
    this.price = price;
  }
  public Cart(int id, String name, int price) {
    super();
    this.id = id;
    this.name = name;
    this.price = price;
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + id;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    result = prime * result + price;
    return result;
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    Cart other = (Cart) obj;
    if (id != other.id)
      return false;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    if (price != other.price)
      return false;
    return true;
  }
  @Override
  public int compareTo(Cart o) {
    return this.id-o.id;
  }
}

输出：

七.SortedSet

1.first()和last()方法分别获取了集合中的最小值和最大值。

2.subSet()方法获取了子集合

subSet()方法的第一个参数inclusive，第二个参数exclusive，即包含起始元素但不包含结束元素

3.tailSet()方法尾部子集合

package com.ctb.set;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
/**
 * SortedSet
 * @author biao
 *
 */
public class Demo5 {
  public static void main(String[] args) {
    SortedSet<Integer> set = new TreeSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);
    set.add(5);
    System.out.println( set.first()); // 1
    System.out.println( set.last()); // 5
    SortedSet<Integer> subSet = set.subSet(2, 4);
    System.out.println(subSet); // [2, 3]
    SortedSet<Integer> tailSet = set.tailSet(3);
    System.out.println( tailSet); // [3, 4, 5]
  }
}

祝大家在梦想之路披荆斩棘！！


文章标签：
存储
Java
孤留光乩
目录
相关文章
听白
|
2月前
|
存储 NoSQL 关系型数据库
Redis 集合(Set)
10月更文挑战第17天
听白
40 5
众所周知
|
2月前
|
算法 Java 数据处理
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。
从HashSet到TreeSet，Java集合框架中的Set接口及其实现类以其“不重复性”要求，彻底改变了处理唯一性数据的方式。HashSet基于哈希表实现，提供高效的元素操作；TreeSet则通过红黑树实现元素的自然排序，适合需要有序访问的场景。本文通过示例代码详细介绍了两者的特性和应用场景。
众所周知
46 6
龙大吉
|
2月前
|
存储 Java 数据处理
Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位
【10月更文挑战第16天】Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位。本文通过快速去重和高效查找两个案例，展示了Set如何简化数据处理流程，提升代码效率。使用HashSet可轻松实现数据去重，而contains方法则提供了快速查找的功能，彰显了Set在处理大量数据时的优势。
龙大吉
34 2
东方睿赢
|
2月前
|
存储 算法 Java
Java Set因其“无重复”特性在集合框架中独树一帜
【10月更文挑战第14天】Java Set因其“无重复”特性在集合框架中独树一帜。本文深入解析Set接口及其主要实现类（如HashSet、TreeSet）如何通过特定的数据结构（哈希表、红黑树）确保元素唯一性，并提供最佳实践建议，包括选择合适的Set实现类和正确实现自定义对象的`hashCode()`与`equals()`方法。
东方睿赢
35 3
爱吃香蕉的猫
|
27天前
set集合
HashSet(无序，唯一): 基于 HashMap 实现的，底层采用 HashMap 来保存元素。 LinkedHashSet: LinkedHashSet 是 HashSet 的子类，并且其内部是通过 LinkedHashMap 来实现的。 TreeSet(有序，唯一): 红黑树(自平衡的排序二叉树)。
爱吃香蕉的猫
24 1
大树营养快线
|
1月前
|
存储 Java
判断一个元素是否在 Java 中的 Set 集合中
【10月更文挑战第30天】使用`contains()`方法可以方便快捷地判断一个元素是否在Java中的`Set`集合中，但对于自定义对象，需要注意重写`equals()`方法以确保正确的判断结果，同时根据具体的性能需求选择合适的`Set`实现类。
大树营养快线
32 7
大树营养快线
|
1月前
|
存储 Java 开发者
在 Java 中，如何遍历一个 Set 集合？
【10月更文挑战第30天】开发者可以根据具体的需求和代码风格选择合适的遍历方式。增强for循环简洁直观，适用于大多数简单的遍历场景；迭代器则更加灵活，可在遍历过程中进行更多复杂的操作；而Lambda表达式和`forEach`方法则提供了一种更简洁的函数式编程风格的遍历方式。
大树营养快线
44 1
大树营养快线
|
1月前
|
Java 开发者
从 Java 中的 Set 集合中删除元素
【10月更文挑战第30天】
大树营养快线
67 1
东方睿赢
|
2月前
|
存储 Java 数据处理
Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。
【10月更文挑战第16天】Java Set：无序之美，不重复之魅！Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。通过 hashCode() 和 equals() 方法实现唯一性，适用于需要唯一性约束的数据处理。示例代码展示了如何使用 HashSet 添加和遍历元素，体现了 Set 的高效性和简洁性。
东方睿赢
39 4
众所周知
|
2月前
|
存储 Java 数据处理
Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。
Java Set：无序之美，不重复之魅！Set 是 Java 集合框架中的一个接口，不包含重复元素且不保证元素顺序。它通过 hashCode() 和 equals() 方法确保元素唯一性，适用于需要唯一性约束的数据处理。示例代码展示了如何使用 HashSet 实现这一特性。
众所周知
32 5