黑马程序员_009_TreeSet的两种排序方式和HashSet保持元素唯一性的方式

最新推荐文章于 2022-11-22 13:53:53 发布
最新推荐文章于 2022-11-22 13:53:53 发布
阅读量761 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVA知识点对比总结 文章标签： TreeSet HashSet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011453546/article/details/17505733
本文详细介绍了HashSet如何通过元素的hashCode()和equals()方法保证元素的唯一性，并演示了TreeSet的两种排序方式：自然排序与自定义排序器。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

-------  android培训、 java培训、期待与您交流！ ----------
1、HashSet保持元素唯一性的方式
HashSet是如何保证元素的唯一性？是通过元素的两个方法，hashCode()和equals()来完成。如果元素的HashCode值相同，才会判断equals是否为true，如果元素的哈希值不同，不会调用equals。另外：若两个元素的值不同，地址值相同，过程是这样的：先比较地址值，发现相同，然后比较equals，发现值不同，则，在哈希表中，该地址值下回存入两个不同的对象，即一个地址两个对象，在打印时，可打印出这两个对象。

HashSet数据结构式哈希表，线程是非同步的。保证元素唯一性的原理，判断元素的hashCode是否相同，如果相同，还会继续判断元素的equals方法，是否为true

注意：对于判断元素是否存在以及删除等操作，都依赖于元素的hashcode和equals方法
class Demo
{
        /*
        public int hashCode()
        {
                return 60;//返回值3c, 十六进制形式
        }
        */
}
class HashSetDemo
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                Demo d = new Demo();
                Demo d1 = new Demo();
                sop(d);//因为重写了hashCode(),所以打印的d和d1的地址值是一样的
                sop(d1);//这是因为，d.toString()时，调用hashCode(),返回d的哈希值
                            //但是我们重写后，返回的是3c，因此d  和d1打印地址值相同

                HashSet  hs = new HashSet();
                hs.add("java01");
                hs.add("java02");
                hs.add("java03");
                hs.add("java04");
                hs.add("java03");
                hs.add("java04");

                sop(hs.add("java"));//add方法返回值为boolean的，此时打印true，能存
                sop(hs.add("java"));//应为hs中已经存在java，不能继续存入，打印false
                Iterator it = hs.iterator();
                while(it.hasNext())//打印后只1234,因为HashSet中元素不重复
                        sop(it.next())
        }
}
2、TreeSet的两种排序方式
排序的第一种方式：让元素自身具备比较性，元素实现compareable接口，覆盖compareTo()方法。这种方式也称为元素的自然顺序，或默认顺序。

        
class TreeSetDemo
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet();    
                ts.add("fd");
                ts.add("cdf");
                ts.add("Dd");
                ts.add("b");
                Iterator it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next());
                        //结果：     Dd     b         cdf       fd 
                        //按首字母值排序，升序
                }


        }
}

/*
向TreeSet中存储自定义对象：重写compareTo方法，按我们自定义的方式返回值，先比较主要元素，若主要元素相同就比较次要元素。
*/
class TreeSetDemo
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet();    
                ts.add(new Student("zhangsan",19);
                ts.add(new Student("lisi",30);
                ts.add(new Student("wangwu",19);
                ts.add(new Student("zhangsan",13);

                Iterator it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next());
                     
                }
        }
}
class Student implements Comparable
{
        private String name;
        private int age;
        Student(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
        public int compareTo(Object obj)
        {
                /*此时按升序排列
                if(!(obj instanceof Student))
                        throw new RunTimeException("不是学生");
                Student s = (Student)obj;
                if(this.age>s.age)
                        return 1;
                if(this.age==s.age)
                         return (this.name).compareTo(s.name);//String类本身就实现了Compareable接口，有compareTo方法
                return -1;*/

                //如果这样，那么元素是按存入的顺序排列的，存入元素时，会自动调用compareTo,返回1表示大于，返回0表示等于（此时不存入），返回-1表示小于。在这里全返回1表示后存入的对象比前一个对象大。
                return  1；
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                retrun age;
        }
}


排序的第二种方式：当元素自身不具备比较性，或具备的比较性不是所需要的。这时需要让集合自身具备比较性。在集合一初始化时，就有了比较方式。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数

当两种排序都存在时，以比较器为主


class Student implements Comparable
{
        private String name;
        private int age;
        Student(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
        public int compareTo(Object obj)
        {
               此时按升序排列
                if(!(obj instanceof Student))
                        throw new RunTimeException("不是学生");
                Student s = (Student)obj;
                if(this.age>s.age)
                        return 1;
                if(this.age==s.age)
                         return (this.name).compareTo(s.name);//String类本身就实现了Compareable接口，有compareTo方法
                return -1;

              
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                retrun age;
        }
}
class TreeSetDemo
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet (new MyCompare());     //表示使用指定比较器
                ts.add(new Student("zhangsan",19);
                ts.add(new Student("lisi",30);
                ts.add(new Student("wangwu",19);
                ts.add(new Student("zhangsan",13);

                Iterator it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next());
                        //结果：     Dd     b         cdf       fd 
                        //按首字母值排序，升序
                }
        }
}
定义一个类，实现Comparator接口，覆盖compare方法。
class MyCompare implements Comparator//自定义比较器
{
        public int compare(Object c1,Object c2)
        {
                Student s1 = (Student)o1;
                Student s2 = (Student)o2;
                int  num = s1.getName().compareTo(s2.getName());
                if(num==0)//当name相同时，比较age
                {
                        return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge());
                }
                return num;
        }
}

比较器调用过程： 就是让集合具备比较的功能，使用集合构造函数方法
创建TreeSet集合对象，此时：
         TreeSet ts = new TreeSet(new MyCompare()); 表示使用自定义比较器
       
创建类实现接口Comparator，覆盖接口的compare方法
        class MyCompare implements Comparator//自定义比较器
        {
        public int compare(Object c1,Object c2)
        {
自定义比较的方式，最后的返回值
return 正数或负数或0；一般就是1  -1  0
}
}
向TreeSet对象中添加元素，此时元素就自动的，按自定义的比较器在集合内排序存放

compareTo调用过程理解： 让集合元素具备比较性
创建TreeSet集合对象，此时：
           TreeSet ts = new TreeSet(); 表示使用compareTo()方法
创建类实现Comparable接口，覆盖compare方法。并且此类生成的对象，是准备向集合中添加的元素。 在覆盖后的compare方法中对该类的成员如name  age等进行比较，返回值1 -1 或0
向集合中添加元素，集合就会自动调用compare方法，按覆盖后的compare方法进行排序存放
TreeSet保证元素的 排序和唯一性 的原理
暖心~的博客
09-09 6351
TreeSet是如何保证元素的排序和唯一性的呢？ 通过查看TreeSet的add方法,我们发现它的底层是通过一个Map集合的put方法实现的，因此我们只要去找这个put方法的源码就知道了，我们发现这个Map是NavigableMap类型的，但是NavigableMap居然是个接口，那怎么办呢？于是我们就要想到去找这个NavigableMap接口的实现类看这个实现类的put方法即可。 于是我
黑马程序员java自学笔记（包括Java环境配置与IDEA的下载地址）
qq_66734705的博客
05-19 1217
万物皆为对象，客观存在的事物都是对象类是对现实生活中一类具有共同属性和行为的事物的抽象属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值行为：对象能够执行的操作不包含重复元素的集合没有带索引的方法，所以不能使用普通for循环遍历是单例集合的顶层接口，他表示一组对象，这些对象也称为Collection的元素JDK不提供此接口的任何直接实现，他提供更具体的子接口（如Set和List）实现是针对集合操作的工具类数据结构是计算机存储、组织数据的方式。
set集合的唯一性(二)——TreeSet
Optimistic
11-26 920
 TreeSet     它既然属于set，那么它也遵循无序、唯一，但TreeSet说无序是指它的存入顺序和取出顺序不一致，而它取出的顺序也是有序的，是按照自然循序(即字典顺序)取出的。     保证TreeSet唯一性共有两种方法:                方法一：通过自定义类实现comparable接口并重写compareTo()来保证唯一性； 例： package co
TreeSet集合如何保证元素唯一
Java笔记虾
09-08 2017
TreeSet： 1.特点 TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列 2.使用方式 a.自然顺序(Comparable) TreeSet类的add()方法中会把存入的对象提升为Comparable类型 调用对象的compareTo()方法和集合中的对象比较(当前存入的是谁,谁就会调用compareTo方法) 根据compa...
TreeSet类的排序
iteye_5722的博客
09-07 211
一 TreeSet类的排序概述 TreeSet采用红黑树的数据结构对元素进行排序。TreeSet支持两种排序方法：自然排序和定制排序。 自然排序：TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间大小关系，然后将集合元素按升序排列，这种方式就是自然排列。 定制排序：TreeSet借助于Comparator接口的帮助。该接口里包含一个的int com...
HashSet，TreeSet是怎么保证元素唯一性的？
徐明晓的博客
08-05 361
HashSet利用的是hashmap中的key不能唯一的原则。通过判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。 TreeSet底层保证元素唯一性是通过Comparable或者Comparator接口实现。 ...
java黑马程序员集合进阶
02-10
为了保证元素唯一性，在向`HashSet`中添加对象时会调用该对象的`hashCode()`和`equals()`方法来判断是否已经存在相同元素。 ```java import java.util.HashSet; public class Student { private String name; ...
黑马程序员--集合框架
sinat_29779023的博客
07-28 448
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- 注：视频来源，毕向东老师的 JAVA 基础视频。集合框架 概论： 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。接口：即表示集合的抽象数据类型。接口提供了让我们对集合中所表示的内容进行单独操作的可能。实现：也就是集合框架中
黑马程序员入学Java知识——精华总结
u014563778的专栏
04-17 3837
黑马程序员入学Java知识——精华总结   J2SE部分，Java高新技术部分，7K面试题部分等黑马入学要求的知识点总结！   一、黑马程序员—java概述与基础知识 6 1、何为编程？ 6 2、Java语言概述，历史、特点 6 3、什么是跨平台性？原理是什么？JVM 7 4、Jre和Jdk的区别? 7 5、java虚拟机JVM 8 6、 Java程序运行机制 8 7
黑马程序员———java 集合框架
lqf123lrf的专栏
10-11 365
java 集合框架 集合类 为什么出现集合类？   面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，  集合就是存储对象最常用的一种方式。  数组和集合类同是容器，有何不同？  数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集  合只能存储对象。而数组里存的都是指定类型的元素，而集合中可存放不同类型
TreeSet保证元素唯一并实现排序的原理
csdn_liuwen的博客
09-11 4244
TreeSet：根据构造方法的不用，选择使用自然排序或者比较器排序。 按照实际的需求，可以对元素进行排序。并且保证唯一。 怎么保证的呢? 排序：底层结构是二叉树。按照树节点进行存储和取出。 两种实现： A:自然排序(元素具备比较性) TreeSet的无参构造，要求对象所属的类实现Comparable接口。 B:比较器
TreeSet排序方法
qq_36558578的博客
01-14 1848
A: TreeSet集合的特点: 元素唯一,并且可以对元素进行排序 排序: a: 自然排序 b: 使用比较器排序 到底使用的是哪一种的排序取决于,构造方法. B:案例演示: TreeSet存储Integer类型的元素并遍历 存储下列元素: 20 , 18 , 23 , 22 , 17 , 24, 19 , 18 , 24 注意：使用TreeSet集合进行元素的自然排序，那么对元素有要求，要...
TreeSet进行排序的方法
weixin_44424630的博客
09-24 8354
TreeSet进行排序的方法的方法有两种，分别是 一种是类实现Comparable<>方法，重写compareTo(Object o)方法 public class Demo1 { public static void main(String[] args) { Student s1 = new Student("张三",25); Student s2 = new Student("李四",18); Student s3 = new
TreeSet保证元素唯一性
FreeRuner的博客
07-04 652
TreeSet 保存数据步骤： Step1：调用add()方法:时，首先(默认情况下属于自然排序)调用compareTo(Object obj)方法，比较比较； Step2：根据返回值得不同存数据； 详细情况如下图所示: 注：1.TreeSet所添加的元素或对象所在类必须实现comparable接口并重写compareTo(Object obj)方法(自然排序：升序排列)      或实
TreeSet排序
qq_50419321的博客
11-22 3016
TreeSet排序
TreeSet集合的比较方式和元素唯一性的原理。
Kern_的专栏
09-20 874
package aboutCollection; import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; public class comparatorTest { public static void main(String[] args) {
使用TreeSet 进行排序
as875784622的博客
08-02 569
TreeSet特点：因为TreeSet实现了Set接口，所以，数据元素是不可以重复的，但是可以排序。 HashSet接口：必须重写 equals方法和hashcode()方法。只要是排序，无非是返回-1，0，1。 当返回0时，说明对象相同，可以进行去除操作。 首先创建一个科目javabean，提供无参数构造器和带参数构造器。重写toString（） /** * 学习的科目 * * ...
集合的特殊功能之TreeSet集合如何保证元素的唯一及排序的
u010698072的博客
10-17 728
TreeSet集合储存的元素特点是唯一和自动排序，它是如何实现的呢？class TreeSet implements Set { private transient NavigableMap<E,Object> m; public TreeSet() { this(new TreeMap<E,Object>()); } //无参构造执行了n
java treeset 两种排序方式
最新发布
04-27
### Java中TreeSet的两种排序方式 #### 自然排序 自然排序是指通过让对象实现`Comparable`接口来定义其自身的比较逻辑。当一个类实现了该接口后，可以通过重写`compareTo`方法指定如何进行比较。这种方式适用于希望按照某种固定的顺序排列的对象。 以下是基于自然排序的一个示例： ```java import java.util.*; public class Person implements Comparable<Person> { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } @Override public int compareTo(Person other) { return Integer.compare(this.age, other.age); } @Override public String toString() { return "Person{name='" + name + "', age=" + age + "}"; } public static void main(String[] args) { TreeSet<Person> treeSet = new TreeSet<>(); treeSet.add(new Person("Alice", 30)); treeSet.add(new Person("Bob", 25)); treeSet.add(new Person("Charlie", 35)); for (Person person : treeSet) { System.out.println(person); } } } ``` 在这个例子中，`Person`类实现了`Comparable`接口并重写了`compareTo`方法，使得`TreeSet`能够根据年龄字段自动排序[^1]。 --- #### 比较器排序 另一种排序方式是通过向`TreeSet`传递一个自定义的`Comparator`实例来进行排序。这种方法允许在不修改原始类的情况下灵活地调整排序规则。 下面是使用比较器排序的例子： ```java import java.util.*; public class Main { public static void main(String[] args) { Comparator<Person> comparator = (p1, p2) -> p1.getName().compareTo(p2.getName()); TreeSet<Person> treeSet = new TreeSet<>(comparator); treeSet.add(new Person("Alice", 30)); treeSet.add(new Person("Bob", 25)); treeSet.add(new Person("Charlie", 35)); for (Person person : treeSet) { System.out.println(person); } } } class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } @Override public String toString() { return "Person{name='" + name + "', age=" + age + "}"; } } ``` 在此代码片段中，我们创建了一个匿名内部类作为`Comparator`，并通过它指定了按名字升序的方式对`TreeSet`中的元素进行排序[^1]。 --- ### 总结 以上展示了Java中`TreeSet`支持的两种主要排序方式——自然排序和比较器排序。每种方式都有各自的适用场景：如果目标类型的默认排序行为固定，则可以选择自然排序；而当需要动态改变排序策略时，推荐采用比较器排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值