Java集合类中Set类以及HashSet和TreeSet

最新推荐文章于 2024-06-18 09:30:37 发布
最新推荐文章于 2024-06-18 09:30:37 发布
阅读量251 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhw19931201/article/details/106305090
版权

目录

HashSet

TreeSet 

集合框架中的Set类：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

HashSet

特点：

  1. 底层数据结构是哈希表。是线程不安全的。不同步。
  2. HashSet是如何保证元素唯一性的呢？                                                                                                                                是通过元素的两个方法，hashCode和equals来完成。
     如果元素的HashCode值相同，才会判断equals是否为true。
     如果元素的hashcode值不同，不会调用equals。 
  3. 对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

例1：简单应用

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

    HashSet hs=new HashSet();
    //注意：add()返回的是boolean
    System.out.println(hs.add("java1"));
    System.out.println(hs.add("java1"));
    hs.add("java2");
    hs.add("java3");
    hs.add("java3");
    hs.add("java4");
    Iterator it=hs.iterator();
    while(it.hasNext())
    {
      System.out.println(it.next());
    }
  }
}

例2：往hashSet集合中存入自定对象姓名和年龄相同为同一个人，重复元素。 

 

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

    HashSet hs=new HashSet();
    hs.add(new Person("a1",11));
    hs.add(new Person("a2",12));
    hs.add(new Person("a3",13));
    hs.add(new Person("a2",12));

    Iterator it=hs.iterator();
    while(it.hasNext())
    {
      Person p=(Person)it.next();
      System.out.println(p.getName()+"..."+p.getAge());
    }
  }
}
class Person
{
  private String name;
  private int age;
  Person(String name,int age)
  {
    this.name = name;
    this.age = age;
  }
  //重写hasCode
  public int hashCode()
  {
    System.out.println(this.name+"....hashCode");
    return name.hashCode()+age;// 保证哈希值的唯一性
  }

  public boolean equals(Object obj)
  {
    if(!(obj instanceof Person))
      return false;
    Person p = (Person)obj;
    System.out.println(this.name+"...equals.."+p.name);
    return this.name.equals(p.name) && this.age == p.age;
  }
  public String getName()
  {
    return name;
  }
  public int getAge()
  {
    return age;
  }
}

从运算结果可以看出来，每次添加进来的元素先计算hashCode,当添加进a2时由于hashCode一样，再比为较是否为同一个对象，调用equals方法。

例3：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法

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

    HashSet hs=new HashSet();
    hs.add(new Person("a1",11));
    hs.add(new Person("a2",12));
    hs.add(new Person("a3",13));
    hs.add(new Person("a2",12));

    System.out.println(hs.contains(new Person("a2",12)));  //包含时，先判断hashCode，在判断equals
    System.out.println(hs.remove(new Person("a1",11)));  //删除时，先判断hashCode，在判断equals

    Iterator it=hs.iterator();
    while(it.hasNext())
    {
      Person p=(Person)it.next();
      System.out.println(p.getName()+"..."+p.getAge());
    }
  }
}
class Person
{
  private String name;
  private int age;
  Person(String name,int age)
  {
    this.name = name;
    this.age = age;
  }
  //重写hasCode
  public int hashCode()
  {
    System.out.println(this.name+"....hashCode");
    return name.hashCode()+age*37;// 保证哈希值的唯一性37是任意值
  }

  public boolean equals(Object obj)
  {
    if(!(obj instanceof Person))
      return false;
    Person p = (Person)obj;
    System.out.println(this.name+"...equals.."+p.name);
    return this.name.equals(p.name) && this.age == p.age;
  }
  public String getName()
  {
    return name;
  }
  public int getAge()
  {
    return age;
  }
}

TreeSet 

  1. 可以对Set集合中的元素进行排序 ;
  2. 底层数据结构是二叉树;
  3. 保证元素唯一性的依据:compareTo方法return 0

               TreeSet排序的第一种方式：让元素自身具备比较性。
                元素需要实现Comparable接口，覆盖compareTo方法。
                这种方式也称为元素的自然顺序，或者叫做默认顺序。

                TreeSet的第二种排序方式。
                当元素自身不具备比较性时，或者具备的比较性不是所需要的。
                这时就需要让集合自身具备比较性。
                在集合初始化时，就有了比较方式。

例1：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序 。

class  TreeSetDemo {
  public static void main(String[] args) {
    TreeSet ts=new TreeSet();
    ts.add(new Student("Mike",10));
    ts.add(new Student("Tom",12));
    ts.add(new Student("Mi",17));
    ts.add(new Student("Jim",10));
    Iterator it=ts.iterator();
    while(it.hasNext())
    {
      Student s=(Student)it.next();
      System.out.println(s.getName()+"..."+s.getAge());
    }
  }
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
  private String name;
  private int age;

  Student(String name,int age)
  {
    this.name = name;
    this.age = age;
  }
  //覆盖compareTo方法。
  public int compareTo(Object obj)
  {
    //return 0; //所有元素相同
    if(!(obj instanceof Student))
      throw new RuntimeException("不是学生对象");
    Student s = (Student)obj;
    //System.out.println(this.name+"....compareto....."+s.name);
    //根据年龄进行排序
    if(this.age>s.age)
      return 1;
    if(this.age==s.age)  //主要条件相同，比较次要条件姓名
    {
      return this.name.compareTo(s.name);  //此处的compareTo为String中的比较方法，按字典顺序比较两个字符串
    }
    return -1;

  }
  public String getName()
  {
    return name;

  }
  public int getAge()
  {
    return age;
  }
}

例2：当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。当两种排序都存在时，以比较器为主。

定义一个类，实现Comparator接口，覆盖compare方法。

//按照比较器进行排序
class  CollectionDemo {
  public static void main(String[] args) {
    TreeSet ts=new TreeSet(new MyCompare());
    ts.add(new Student("Mike",10));
    ts.add(new Student("Tom",12));
    ts.add(new Student("Mi",17));
    ts.add(new Student("Aim",10));
    Iterator it=ts.iterator();
    while(it.hasNext())
    {
      Student s=(Student)it.next();
      System.out.println(s.getName()+"..."+s.getAge());
    }
  }
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
  private String name;
  private int age;

  Student(String name,int age)
  {
    this.name = name;
    this.age = age;
  }
  //覆盖compareTo方法。
  public int compareTo(Object obj)
  {
    if(!(obj instanceof Student))
      throw new RuntimeException("不是学生对象");
    Student s = (Student)obj;
    //System.out.println(this.name+"....compareto....."+s.name);
    //根据年龄进行排序
    if(this.age>s.age)
      return 1;
    if(this.age==s.age)  //主要条件相同，比较次要条件姓名
    {
      return this.name.compareTo(s.name);  //此处的compareTo为String中的比较方法，按字典顺序比较两个字符串
    }
    return -1;

  }
  public String getName()
  {
    return name;

  }
  public int getAge()
  {
    return age;
  }
}
class MyCompare implements Comparator
{
  public int compare(Object o1,Object o2)
  {
    Student s1 = (Student)o1;
    Student s2 = (Student)o2;

    int num = s1.getName().compareTo(s2.getName());   //调用String中的compareTo方法，按字典进行排序
    //主要条件相同，判断次要条件
    if(num==0)
    {
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1.getAge()==s2.getAge())
				return 0;
			return -1;

    }
    return num;
  }
}

 

例3：按照字符串长度排序。（使用比较器排序）

 

class  CollectionDemo {
  public static void main(String[] args) {
    TreeSet ts=new TreeSet(new StrLenComparator());  //将比较器对象作为参数传入集合构造函数中
    ts.add("as");
    ts.add("adf");
    ts.add("dert");
    ts.add("ed");

    Iterator it=ts.iterator();
    while(it.hasNext())
    {
      System.out.println(it.next());
    }

  }
}
//实现Comparator接口
class StrLenComparator implements Comparator
{
  //复写compare方法
  public int compare(Object o1,Object o2)
  {
    String s1=(String)o1;  //向下转
    String s2=(String)o2;
    if(s1.length()>s2.length())
      return 1;
    if(s1.length()==s2.length())
      return s1.compareTo(s2);
    return -1;
  }
}

 注意：使用比较器时，将比较器对象作为参数传入集合构造函数中。

 

 

 

 

 

StrawberryBoy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Java中HashSet和TreeSet的区别
08-30
HashSet 和 TreeSet 是 Java 中两个常用的集合类，它们都实现了 Set 接口，但它们之间有很大的区别。本文将详细介绍 HashSet 和 TreeSet 的区别，帮助大家更好地理解和使用这些集合类。 HashSet HashSet 是一个...
HashSet和TreeSet的区别
热门推荐
qq_42216184的博客
11-13 1万+
相同点：单例集合，数据不可重复         不同点1：底层使用的储存数据结构不同：       1，Hashset底层使用的是HashMap哈希表结构储存        2，而Treeset底层用的是TreeMap树结构储存。          不同点2：储存的数据保存唯一方式不用。        1，Hashset是通过复写hashCode()方法和equals()方法来保证的。   ...
Java Set类的常见实现类 TreeSet和HashSet
程序员小章的博客
08-21 763
Set集合的常用实现类 TreeSet和HashSet HashSet HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。 HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。 特点： 不能保证元素的排列顺序 HashSet 不是线程安全的 集合元素可以是 null HashSet 集合判断两个元素相等的标准： 两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方
JAVA小知识23：set与HashSet
最新发布
jialuosi的博客
06-18 972
索引8为第一个添加，索引3为第二个添加，当第二个添加完成后，索引8的值会记录索引3的地址值，索引3也会记录索引8的地址值。LinkedHashSet继承自HashSet，上面我们说到LinkedHashSet是有序，不可重复的，其实这里的有序指的是存和取的顺序是有序的。因为本身添加就是根据哈希值计算出来的地址，所以添加的时候顺序就是不固定的，但是取值的时候顺序是固定的，从数组索引0开始查找取值。当LinkedHashSet遍历的时候，就会遍历双向链表，所以存和取的顺序就相同了。
java的集合中的Set以及set的实现类HashSet和TreeSet
HKDxiaofan的博客
12-20 2474
Set接口 Set是Collection的子接口,与List相对 Set集合中的元素的特点是1,无序性 2,无下标3,无重复的元素 Set是个接口,所以无法直接创建对象,要依赖它的实现类来创建对象 Set的实现类有两个,一个是HashSet,另一个是TreeSet Set<String> set = new HashSet<>(); set.add("c"); set.
Java集合-Set接口-HashSet和TreeSet实现类
baidu_38126306的博客
09-22 283
Java集合 -> Set接口 -> HashSet和TreeSet 1. Set接口特性 Set接口继承自Collection，Set 接口中没有新增方法，方法和Collection保持一致； Set特点：无序、不可重复。无序指的是Set中的元素没有索引，因此只能通过遍历查找。 Set的常用实现类：HashSet、TreeSet等。 import java.util.Arrays; import java.util.Collection; import java.util.HashSet;
set集合判断集合中是否有无元素_Set接口
weixin_39627665的博客
11-21 771
Set接口是Collection的子接口，set接口没有提供额外的方法。 Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。 Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals 方法。因此存放到Set集合中的元素一定要注意equals方法的重写。Set的常用实现类有：HashSet、TreeSet、LinkedHashSe...
java集合类源码分析之Set详解
08-29
Java集合类源码分析之Set详解 Java集合类中的Set Interface是用于存储无序、不可重复元素的集合接口。...Set Interface是Java集合类中的一个重要部分，它提供了便捷的方式来存储和处理无序、不可重复的元素。
Java Set集合的遍历及实现类的比较
08-30
总结，Java Set集合提供了HashSet和TreeSet等实现类，它们各有优势。HashSet在存储速度和空间效率上有优势，但不保证元素顺序；而TreeSet则提供了有序的存储，但相比HashSet，它的插入和查询速度可能稍慢。选择哪种...
Java集合类中文介绍
09-04
Java集合类是Java编程语言中用于存储和管理对象的关键组件，位于`java.util`包下。集合类框架提供了一系列接口和实现，使开发者能够高效地处理数据。本文将深入介绍这个框架，特别是针对Collection、List、Set以及...
java集合分类总结.doc
12-21
Arrays和Collections是Java集合中的两个工具类。Arrays类包含用来操作数组的各种方法，如排序和搜索等。Collections类主要提供了在collection上进行操作的方法，如排序、查找等。 学习Java集合需要掌握以下几个方面...
Set集合——hashSet、treeSet
隔壁的博客
07-26 1083
J2EE 目录 J2EE 一、HashSet 1、概念： 2、Hashset 三、Hashset底层去重原理 四、treeset的两种排序 1、特点： 2、自然排序 二、比较器排序 总结： 前言：这篇分享treeset两种排序的使用，HashSet（就是HashMap）仅初步了解去重原理。 一、HashSet 1、概念： 无序（存储顺序和取出顺序无序），唯一。 对于无序易产生误区：我们有顺序的对元素进行存储，set是按照它自己的存储方式对我们的元素进行储存，然后输出来的顺序
treeset和hashset
weixin_43613968的博客
03-21 389
TreeSet的添加、删除、查找操作的时间复杂度都是O(log n)，因此在数据量较小的情况下，HashSet和TreeSet的效率差别不大，但在数据量较大的情况下，TreeSet的效率会比HashSet更高。HashSet是基于哈希表实现的，它不保证元素的顺序，也不允许重复元素。HashSet的添加、删除、查找操作都是常数时间复杂度的，因此在大量数据的情况下，HashSet的效率比较高。如果不需要保证元素的顺序，或者需要快速的添加、删除、查找操作，可以选择使用HashSet。
HashSet与TreeSet详解
qq_41800568的博客
08-10 1559
先介绍下Java中的集合的概念 1.集合是JavaAPI所提供的一系列类，用来动态存放多个对象----集合只能存放对象 2.集合与数组的区别是，集合长度可变，且存放元素不受限定，主要是引用类型。 3.集合全部支持泛型，是一种数据安全的用法 集合框架图 集合分两大家族： Collection(接口)家族：存放单一对象 Map(接口)家族：存放键值对(key,value) 先说Collection(...
set和hashset区别及用法
学而时习
04-04 1万+
【Set和HashSet】 1、Set ​ 概念：Set集合类似于一个瓶罐子，集合中的多个对象之间没有明显的顺序排列。 ​ 特点如下： ​ set集合不允许包含相同的元素，如果试图要把两个相同的元素加入到同一个Set集合中，则将添加失败；add方法返回false，且新元素不会被加入。【无序容器】 ​ 使用equals方法判断两个对象是否相同，不使用==运算符 ​ 最多包含一...
HashSet 和 TreeSet 的区别
m0_69057918的博客
08-28 577
HashSet 和 TreeSet 的区别 以及 排序规则的说明
Set之TreeSet与HashSet
好看的皮囊千篇一律，有趣的灵魂万里挑一。
01-22 1199
HashSet是基于哈希表实现的，他可以快速的进行插入、删除和查找操作，时间复杂度为O（1） ，HashSet不会保证元素的顺序，原因在于，他是根据元素的哈希值来存储和查询元素的，如果需要按照元素的顺序进行遍历集合，可以使用LinkedHashSet,他是HashSet的子类，内部使用的是链表维护元素的顺序。
Java HashSet与TreeSet总结
liaorongxiao的博客
04-05 1196
一、HashSet简介 HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。 HashSet 允许有 null 值。 HashSet 是无序的，即不会记录插入的顺序。 HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。 HashSet 实现了 Set 接口。 set容器的特点是不包含重复元素，也就是说自动去重，算法题中经常应用的特点。 HashSet 中的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值