Set集合详解-阿里云开发者社区

Set集合详解

2023-10-25 48

版权

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

简介： 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