60 java集合和泛型_10 _Set实现类 _TreeSet

最新推荐文章于 2021-03-01 21:14:35 发布
最新推荐文章于 2021-03-01 21:14:35 发布
阅读量178 收藏 1
点赞数 1
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/107417700
版权

文章目录

Set实现类

  1. HashSet 【重点】 :

    • 基于HashCode计算元素存放位置，实现元素不重复。（存储结构是一个哈希表）
    • 当存入元素的哈希码相同时，会调用equals进行确认， 如结果为true, 则拒绝后者存入。

  2. TreeSet：（set集合是无序的，而TreeSet，对元素进行了排序）

    • 基于排列顺序实现元素不重复。
    • 实现了SortedSet接口，对集合元素自动排序。
    • 元素对象的类型必须实现Comparable接口，指定排序规则。（否则它并不知道怎么去判断大小）
    • 通过CompareTo方法确定是否为重复元素。

TreeSet存储结构：红黑树

  1. 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。

  2. 红黑树是在1972年由[Rudolf Bayer](https://baike.baidu.com/item/Rudolf Bayer/3014716)发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。

  3. 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。

  4. 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。

  5. 简介：

    • 红黑树是一种特定类型的二叉树，它是在计算机科学中用来组织数据比如数字的块的一种结构。若一棵二叉查找树是红黑树，则它的任一子树必为红黑树.。

    • 红黑树是一种平衡二叉查找树的变体，它的左右子树高差有可能大于 1，所以红黑树不是严格意义上的平衡二叉树（AVL），但 对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。

    • 由于每一颗红黑树都是一颗二叉排序树，因此，在对红黑树进行查找时，可以采用运用于普通二叉排序树上的查找算法，在查找过程中不需要颜色信息。

    • 左边的节点是要比右边的节点小的

      ​ 在这里插入图片描述

TreeSet的使用

代码1：

package com.wlw.collection.set;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * TreeSet的使用
 * 存储结构：红黑树
 */
public class TreeSet_Demo01 {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();

        //1.添加
        treeSet.add("xvy");
        treeSet.add("ade");
        treeSet.add("hello");
        //treeSet.add("ade"); //不会添加
        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());

        //2.删除
        /*
        treeSet.remove("hello");
        System.out.println("删除之后，元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
        */

        //3.遍历
        //3.1 增强for
        System.out.println("----------3.1 增强for---------");
        for (String s : treeSet) {
            System.out.println(s);
        }

        //3.2迭代器
        System.out.println("----------3.2迭代器---------");
        Iterator<String> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }

        //4.判断
        System.out.println(treeSet.contains("asd")); //false
        System.out.println(treeSet.isEmpty()); //false
    }
}
/*
元素个数：3
[ade, hello, xvy]
----------3.1 增强for---------
ade
hello
xvy
----------3.2迭代器---------
ade
hello
xvy
false
false
*/

代码2：

package com.wlw.collection.set;

import java.util.Iterator;
import java.util.TreeSet;

/**
 * TreeSet保存数据
 * 存储结构：红黑树
 * 元素对象的类型必须实现Comparable接口，重写compareTo()方法,指定排序规则。
 *      如果compareTo()方法返回值为0，则认为是重复元素
 */
public class TreeSet_Demo02 {
    public static void main(String[] args) {
        TreeSet<Person> treeSet = new TreeSet<>();

        Person p1 = new Person("zhangsan",10);
        Person p2 = new Person("hello",20);
        Person p3 = new Person("xyz",30);
        Person p4 = new Person("zhangsan",40);
        //1.添加
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);
        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
        /*
         *第一次运行报类型转换异常：无法比较，这是因为我们存储的元素类型 没有实现Comparable接口，指定排序规则。
         * Exception in thread "main" java.lang.ClassCastException: com.wlw.collection.set.Person cannot be cast to java.lang.Comparable
         */

        //2.删除

        /*
        //treeSet.remove(p4);
        treeSet.remove(new Person("zhangsan",40)); //也是可以删除的，因为我们重写了比较CompareTo()方法，判断它两是一样的
        System.out.println("删除之后，元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
        */

        //3.遍历
        //3.1 增强for
        System.out.println("----------3.1 增强for---------");
        for (Person person : treeSet) {
            System.out.println(person.toString());
        }

        //3.2迭代器
        System.out.println("----------3.2迭代器---------");
        Iterator<Person> iterator = treeSet.iterator();
        while (iterator.hasNext()){
            Person person = iterator.next();
            System.out.println(person.toString());
        }
        //4.判断
        System.out.println(treeSet.contains(p1)); //true
        System.out.println(treeSet.contains(new Person("zhangsan",10)));//true,因为我们重写了比较CompareTo()方法，判断它两是一样的
        System.out.println(treeSet.isEmpty()); //false
    }
}

/*
元素个数：4
[Person{name='hello', age=20}, Person{name='xyz', age=30}, Person{name='zhangsan', age=10}, Person{name='zhangsan', age=40}]
----------3.1 增强for---------
Person{name='hello', age=20}
Person{name='xyz', age=30}
Person{name='zhangsan', age=10}
Person{name='zhangsan', age=40}
----------3.2迭代器---------
Person{name='hello', age=20}
Person{name='xyz', age=30}
Person{name='zhangsan', age=10}
Person{name='zhangsan', age=40}
true
true
false

*/

/*
元素对象的类型必须实现Comparable接口，重写compareTo()方法,指定排序规则。
 *      如果compareTo()方法返回值为0，则认为是重复元素
*/
package com.wlw.collection.set;

import java.util.Objects;

public class Person implements Comparable<Person>{
    private String name;
    private int age;

    //无参构造
    public Person() {
    }

    //有参构造
    public Person(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 String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //自动生成的
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    //自动生成的
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    //重写compareTo,定义排序规则
    //先按名字比，再按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.getAge() - o.getAge();

        return n1==0?n2:n1;
    }

    /* 自己写的
    @Override
    public int hashCode() {
       int i1 = this.name.hashCode();
       int i2 = this.name.hashCode();
       return i1 + i2;
    }

    @Override
    public boolean equals(Object o) {
        //1.判断是否一样
        if (this == o){
            return true;
        }
        //2.判断是否为空
        if (o == null){
            return false;
        }
        //3.判断是否是Person类型
        if(this.getClass() == o.getClass()){

        }
        if(o instanceof Person){
            //4.类型转换
            Person p = (Person) o;
            //5.比较数据
            if(this.name.equals(p.getName()) && this.age == p.getAge()){
                return true;
            }
        }
        return false;

    }
*/


}

Comparator 接口

  1. Comparator：实现定制比较（比较器）
  2. Comparable：可比较的
package com.wlw.collection.set;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
* TreeSet保存数据
* 存储结构：红黑树
* 1. Comparator：实现定制比较（比较器）
* 2. Comparable：可比较的
*/
public class TreeSet_Demo03 {
   public static void main(String[] args) {
       //创建集合，并指定比较规则
       TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
           @Override
           public int compare(Person o1, Person o2) {
               //先按年龄，再按名字
               int n1 = o1.getAge() - o2.getAge();
               int n2 = o1.getName().compareTo(o2.getName());
               return n1==0?n2:n1;
           }
       });

       Person p1 = new Person("zhangsan",10);
       Person p2 = new Person("hello",20);
       Person p3 = new Person("xyz",30);
       Person p4 = new Person("zhangsan",20);
       //1.添加
       treeSet.add(p1);
       treeSet.add(p2);
       treeSet.add(p3);
       treeSet.add(p4);
       System.out.println("元素个数："+treeSet.size());
       System.out.println(treeSet.toString());

   }
}

/*
元素个数：4
[Person{name='zhangsan', age=10}, Person{name='hello', age=20}, Person{name='zhangsan', age=20}, Person{name='xyz', age=30}]
*/

TreeSet案例

案例要求：

  • 使用TreeSet集合实现字符串按长度进行排序
  • helloworld wangweu zhangsan lisi beijing xian nanjing
  • Comparator：实现定制比较（比较器）

代码：

package com.wlw.collection.set;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * 案例：
 * 要求：使用TreeSet集合实现字符串按长度进行排序
 * helloworld wangweu  zhangsan lisi beijing xian nanjing
 * Comparator：实现定制比较（比较器）
 */
public class TreeSet_Demo04 {
    public static void main(String[] args) {
        //创建集合，并制定比较规则
        TreeSet<String> strings = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length()-o2.length();
                int n2 = o1.compareTo(o2);
                return n1==0?n2:n1;
            }
        });
        strings.add("helloworld");
        strings.add("wangweu");
        strings.add("zhangsan");
        strings.add("lisi");
        strings.add("beijing");
        strings.add("xian");
        strings.add("nanjing");
        System.out.println(strings.toString());
    }
}
/*
[lisi, xian, beijing, nanjing, wangweu, zhangsan, helloworld]
*/
悬浮海
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA代码训练营救——TreeSet的泛型实现
Jungle_hello的博客
05-09 528
import java.util.*; class GenericDemo2 { public static void main(String[] args) { TreeSet<String>ts = new TreeSet<String>(new LenComparator()); ts.add("abcd"); ts.add("c
java---HashSet、TreeSet、泛型
qq_17503037的博客
04-11 293
Vector 集合 的体系： –| Collection 单例集合的根接口 —–| List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。 ———| ArrayList ArrayList 底层是维护了一个Object数组实现的。 特点： 查询速度快，增删慢。 ———| LinkedList LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度...
Java基础之集合框架(二)--TreeSet、泛型
枫叶的专栏
06-30 731
TreeSet类： import java.util.*; /* Set:无序，不可以重复元素。 |--HashSet：数据结构是哈希表。线程是非同步的。 保证元素唯一性的原理：判断元素的hashCode值是否相同。 如果相同，还会继续判断元素的equals方法，是否为true。 |--TreeSet：可以对Set集合中的元素进行排序。 底层数据结构是二叉树。
TreeSet＜E＞ 泛型类
静Yu的博客
01-26 413
TreeSet泛型类 1.TreeSet泛型类在java.util包中 2.TreeSet泛型类创建的对象称为树集 创建TreeSet泛型类对象 假设已经声明了学生类Student，可以创建学生树集 TreeSet tree=new TreeSet (); • tree可以存储Student对象的集合。 • tree可以调用 add(Student s) 将Student对象添加到树集中。 • TreeSet泛型类的其他常用方法，请自行 查阅Java API 以下源代码可以创建字符串树集，并且按照字典序升序
JAVA基础学习(十五)--集合二--TreeSet和泛型
小城我家
09-24 329
一、TreeSet 1.1、TreeSet Set:hashSet:数据结构是哈希表。线程是非同步的。        保证元素唯一性的原理：判断元素的HashCode值是否相同。         如果相同，还会判断元素的equals方法是否为true;       TreeSet: 可以去Set集合中的元素时行 排序。 　　使用二叉树的数据结构。
Java集合、泛型和枚举
最新发布
06-14
Java集合框架是Java编程语言中不可或缺的一部分，它提供了...总的来说，Java集合、泛型和枚举是构建复杂数据结构和实现业务逻辑的关键工具。熟练掌握这些概念和它们的使用方法，将极大地提升Java编程的效率和代码质量。
Week17_第9讲_泛型与集合类.pdf
01-06
通过以上内容的学习，我们不仅理解了泛型的基本概念和使用方法，还深入了解了Java集合类的相关知识，特别是`List`接口及其具体实现类的特点和使用场景。这对于日常开发中高效管理和操作数据具有重要意义。
java_Glossary.rar_Java Glossar_java_Glossary
09-21
7. **集合框架**：包括List（如ArrayList和LinkedList）、Set（如HashSet和TreeSet）和Map（如HashMap和TreeMap），提供了丰富的数据结构和算法。 8. **多线程**：Java内置对多线程的支持，可以创建Thread对象或...
advanced java.rar_advanced java
09-23
2. 高级集合框架：Java集合框架包括接口如`List`, `Set`, `Map`和`Queue`，以及它们的实现如`ArrayList`, `LinkedList`, `HashSet`, `TreeSet`, `HashMap`, `TreeMap`等。`Collections`和`Arrays`类提供了对这些集合...
Java_jihe.rar_java集合
09-20
6. 泛型：Java集合框架广泛使用泛型，确保了类型安全，避免了强制类型转换，提高了代码可读性和健壮性。 7. 集合操作：包括添加元素(add)，删除元素(remove)，检查元素是否存在(contains)，以及各种转换和复制操作...
java创建TreeSet泛型集合_Java-（泛型，集合-Set,HashMap,异常处理）
weixin_39882317的博客
03-01 341
心得体会有时候上课认真听讲效率胜过课后自己花费大量时间再去学习，上课边听边有意识的整理笔记胜过课后去整理自己杂乱的笔记要来的轻松。如果自己在课上写代码的时候有意识的将代码模块化，课后再去整理就会轻松很多。一个好习惯的养成是长久的坚持。今日知识点1.泛型2.集合-Set(hashSet)3.TreeSet进行排序的两种办法4.HashMap的方法5.键值对的两种遍历方式6.异常处理具体操作1.泛型1...
java创建TreeSet泛型集合_TreeSet集合中的 泛型限定 super 问题
weixin_42516119的博客
03-01 159
该楼层疑似违规已被系统折叠隐藏此楼查看此楼import java.util.*;class Person {private String name;Person(String name) {this.name = name;}public String getName() {return name;}}class Student extends Person {Student(String na...
黑马程序员java基础之集合Set中的TreeSet和泛型
yueye12的专栏
01-24 594
Set集合中的TreeSet的使用以及泛型的使用方法，还有泛型的高级使用泛型限定
HashSet、TreeSet及泛型
yangruijing1990的专栏
03-06 388
Set：无序（存入和取出的顺序不一定一致），不能重复，Set集合的功能和Collection是一致的 1、常见的子类： HashSet：底层数据结构是哈希表       HashSet是通过元素的两个方法，hashCode和equals来完    成，如果元素的HashCode值相同，才会判断equals是否为 true，如果元素的hashCode值不同，不会调用equals。 注意：对于
类和对象--构建CPU类，RAM类，CD_ROM类，COMPUTER类
zhf的博客
02-21 4215
问题描述： 构建电脑类：CPU类，RAM类，CD_ROM类，COMPUTER类，并且要求： 1. 声明私有数据成员cpu、ram、cdrom，声明公有成员函数run、stop，可在其中输出提示信息。2. 在main()函数中声明一个Computer类的对象，调用其成员函数。 1. 声明一个CPU类： #include<iostream> using namespace std; en...
动态数组实现(支持泛型)
tree_ifconfig的博客
06-03 763
   动态数组实现(支持泛型)  一、简单介绍     为了复习下数据结构，java框架搞多了，突然觉得数据结构的乐趣。就在这个月，每周会更新自己对以前数据结构的代码的优化，本次，先写了支持泛型的动态数组，所以如果要测试，请使用除八大基本数据类型之外的类型进行测试，也可以使用八大基本数据类型的包装类进行测试(byte -----Byte short-----Short char---Ch...
TreeSet关于泛型的使用
雨安的BLOG
05-31 536
随机数组就是在指定长度的数组中用随机数字为每个元素赋值， 这常用于需要不确定数值的环境，如拼图游戏需要随机数来打乱图片的排序。 可是随机数的重复问题也同时存在。请运用TreeSet集合实现不重复的随机数的数列， 并完成元素的排序，然后输出数组。 /* 泛型关于TreeSet的应用 */ import java.util.*; public class Main { public stati...
泛型 Treeset的排序
weichuchu的博客
08-07 438
1. //将泛型定义在类上 public class Demo { private T demo; //成员方法 public T getDemo() { return demo; } public void setDemo(T demo) { this.demo = demo; } //测试 public class DemoTest { public static
CPU类的设计
zhf的博客
02-21 2589
题目描述： 声明一个CPU类，包含等级(rank)、频率(frequency)、电压(voltage)等属性，有两个公有成员函数run和stop 其中，rank为枚举类型CPU_Rank，声明为enum CPU_Rank{P1=1,P2,P3,P4,P5,P6,P7}； frequency为单位是MHz的整型数，vlotage为浮点型的电压值。 (1). 分别编写不同的set函数和get函数修改、...
java set泛型_Java中的Set集合，泛型，可变参数
05-26
Java中的Set集合是一种不允许重复元素的集合，常用的实现类有HashSet、TreeSet和LinkedHashSet等。其中，HashSet底层是由HashMap实现的，TreeSet底层是由TreeMap实现的，LinkedHashSet则是在HashSet基础上加入链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值