Set集合

最新推荐文章于 2021-02-19 22:38:05 发布
最新推荐文章于 2021-02-19 22:38:05 发布
阅读量172 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ada_yangyang/article/details/80911399
版权

1. Set集合

  • Set集合不允许包含相同的元素，如果试把同个相同的元素加入同一个Set集合中，则添加操作失败。
  • Set判断两个对象是否相同不是使用==运算符，而是根据equals方法

2. HashSet

  • HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。
  • HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。
  • HashSet具有以下特点：
    • 不能保证元素的排列顺序
    • HashSet不是线程安全的
    • 集合元素可以使用null
  • 当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置。
  • 如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，HashSet将会把他们存储在不同的位置，但依然可以添加成功。
  • HashSet 由 HashMap 来定义
    1. 在HashSet中维护了一个HashMap属性
    2. 在调用HashSet的方法时，实际操作的是HashMap的对应的方法
    3. add(Object obj)实际上是吧obj放入了map中：
      public boolean add(E e){
      return map.put(e, PRESENT) == null;
      }
      public boolean contains(Object o){
      return map.containsKey(o)
      }
package test.com.atguigu.javase.lesson7; 

import com.atguigu.javase.lesson7.Person;
import org.junit.Test;

import java.util.HashSet;
import java.util.Set;

/** 
* 关于HashSet
 * 1、HashSet是Set的最典型实现
 * 2、HashSet中不能有重复的元素。判定两个元素相等的标准，equals()方法返回true
 * 3、HashSet根据hashCode()值来存放元素，所以不能保证元素的顺序
*/ 
public class HashSetTestTest { 

    @Test
    public void testAdd(){
        Person p1 = new Person("AA",12);
        Person p2 = new Person("AA",12);

        System.out.println(p1.equals(p2));
        System.out.println(p2.equals(p1));

        Set set = new HashSet();
        set.add(p1);
        set.add(p2);

        System.out.println(set.size());//1
    }
}

3. hashCode()方法

  • HashSet集合判断两个元素相等的标准：两个对象通过equals()方法比较相等，并且两个对象的hashCode()方法返回值也相等。
  • 如果两个对象通过equals()方法返回true，这两个对象的hashCode值也应该相同
  • 重写hashCode()方法的基本原则
    • 在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值
    • 当两个对象的equals()方法比较返回true时，这两个对象的hashCode()方法的返回值也应相等
    • 对象中用作equals()方法比较的Field，都应该用来计算hashCode值
    /**
     * 为什么在hashCode方法中有质数的存在
     * 
     * Person p1:name的hashCode值为1000，age的hashCode为22
     * Person p1:name的hashCode值为22，age的hashCode为1000
     * @return
     */
    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        return result;
    }

4. LinkedHashSet

  • LinkedHashSet是HashSet的子类。
  • LinkedHashSet集合根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
  • LinkedHashSet性能：插入性能略低于HashSet，但在迭代访问Set里的元素时有很好的性能。
  • LinkedHashSet不允许集合元素重复。
package com.atguigu.javase.lesson7;

import org.junit.Test;

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class LinkedHashSetTest {
    @Test
    public void test(){
        Collection collection = new LinkedHashSet();
        collection.add(new Person("AA",12));
        collection.add(new Person("BB",12));
        collection.add(new Person("CC",12));
        collection.add(new Person("DD",12));
        collection.add(new Person("EE",12));

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

5. TreeSet

  • TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态
    • Comparator comparator()
    • Object first()
    • Object last()
    • Object lower(Object e)
    • Object higher(Object e)
    • SortedSet subSet(fromElement, toElement)
    • SortedSet headSet(toElement)
    • SortedSet tailSet(fromELement)
  • TreeSet支持两种排序方法，自然排序和定制排序。默认情况下，TreeSet采用自然排序。

6. 自然排序

  • 排序：TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列
  • 如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口
  • 实现Comparable的类必须实现compareTo(Object obj)方法，两个对象即通过compareTo(Object obj)方法的返回值来比较大小
  • Comparable的典型实现：
    • BigDecimal、BigInteger以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
    • Character：按字符的UNICODE值来进行比较
    • Boolean：true对应的包装类实例大于false对应的包装类实例
    • String：按字符串中字符的UNICODE值进行比较
    • Date、Time：后边的时间、日期比前面的时间、日期大
  • 因为只有相同类的两个实例才会比较大小，所以向TreeSet中添加的应该是同一个类的对象
  • 当需要把一个对象放入TreeSet中，重写该对象对应的equals()方法时，应保证该方法与compareTo(Object obj)方法有一致的结果：如果两个对象通过equals()方法比较返回true，则通过compareTo(Object obj)方法比较应该返回0

7.示例代码

Person类

package com.atguigu.javase.lesson7;

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    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;
    }

    @Override
    public int hashCode() {
        return age;
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person person = (Person)o;
            //return this.name.compareTo(person.name);
            return this.age - person.age;
        }else{
            throw new ClassCastException("不能转为Person类型");
        }
    }
}

TreeSetTest类
package test.com.atguigu.javase.lesson7;

import com.atguigu.javase.lesson7.Person;
import org.junit.Test;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetTest {

/**
 * testTreeSetWithComparable.
 *
 * 1.默认情况下TreeSet要求集合中的元素必须实现Comparable接口
 * Comparable接口中只有一个方法：
 * publi int compareTo(T o)
 * 若返回0，代表两个元素相等。
 * 若放回负数，代表当前元素小。
 * 若返回整数，代表当前元素大。
 *
 * TreeSet会调用每个元素的compareTo()方法去和集合中的每个已经有的元素去比较，进而
 * 决定当前元素在集合中的位置。
 *
 */
@Test
public void testTreeSetWithComparable(){
    TreeSet set = new TreeSet();

    set.add(new Person("AA",12));
    set.add(new Person("CC",13));
    set.add(new Person("EE",14));
    set.add(new Person("DD",15));
    set.add(new Person("BB",16));

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

7. 练习

Student类

package com.atguigu.javase.lesson7;

/**
 * Created by xie on 2018/7/4.
 */
public class Student implements Comparable {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        if(o instanceof Student){
            Student student = (Student)o;
            return student.score - this.score;
        }else{
            throw new ClassCastException("不能转为Student类型");
        }
    }
}

TreeSet类

package com.atguigu.javase.lesson7;

import java.util.Iterator;
import java.util.Scanner;

public class TreeSet {
    public static void main(String args[]) {
        /**
         * 练习：
         * 新建一个Student类，包含：studentName，score
         * 利用Scanner对象输入5个学生的信息
         *
         * student1 name: Tom
         * student1 score: 500
         *
         * ......
         *
         * student5 name:Jerry
         * student5 score:440
         *
         * 把学生信息放入到TreeSet中，利用Comparable的方式来排序
         * 按分数降序输出学生信息
         */


        //1.创建一个TreeSet对象
        java.util.TreeSet set = new java.util.TreeSet();
        //2.由控制台输入5个学生的信息，并把每个学生的对象放入TreeSet中
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            System.out.print("第 " + (i + 1) + "个学生的name：");
            String name = scanner.next();
            System.out.print("第 " + (i + 1) + "个学生的score：");
            int score = scanner.nextInt();
            Student student = new Student(name, score);
            set.add(student);
        }

        //3.遍历TreeSet打印即可
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

8. 定制排序

如果需要实现定制排序，则需要在创建TreeSet集合对象时，提供一个Comparator接口的实现类对象。由该Comparator对象负责集合元素的排序逻辑。
public TreeSet(Comparator< ? super E> comparator)
Method summary
int compare(T o1, T o2): Compares its two arguments for order
boolean equals(Object obj): Indicates whether some other object is “equal to” this comparator
Person1类

package com.atguigu.javase.lesson7;

public class Person1{
    private String name;
    private int age;

    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person1() {
    }

    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 +
                '}';
    }

}

TreeSetTest类：

package test.com.atguigu.javase.lesson7; 

import com.atguigu.javase.lesson7.Person;
import com.atguigu.javase.lesson7.Person1;
import org.junit.Test;

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

public class TreeSetTest {
    @Test
    public void testTreeSetWithComparator(){
    //1.创建Comparator接口的实现类对象
    //实现compare(Object o1, Object o2)来比较两个对象的大小
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person1 && o2 instanceof Person1){
                    Person1 p1 = (Person1)o1;
                    Person1 p2 = (Person1)o2;
                    return p1.getAge() - p2.getAge();
                }else{
                    throw new ClassCastException("不能转为Person类型");
                }
            }
        };
//2.创建TreeSet对象，传入Comparator接口的实现类对象
        TreeSet set = new TreeSet(comparator);


        set.add(new Person1("AA",12));
        set.add(new Person1("CC",13));
        set.add(new Person1("EE",14));
        set.add(new Person1("DD",15));
        set.add(new Person1("BB",16));

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
海边拾贝seebit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于Set集合
12-22
1. Set集合 1.1 Set集合概述 特征： 无序，不可重复 无序：添加顺序和存储顺序不一致,【不代表有排序效果】 不可重复: 在一个Set集合中不能出现相同元素 interface Set --| class HashSet 底层是哈希表存储数据 -...
浅析Java中的set集合类型及其接口的用法
09-02
Java中的Set集合是一种特殊的集合类型，它遵循了不存储重复元素的基本原则。Set接口是Collection接口的子接口，它的设计目标是确保集合中每个元素的唯一性。在Java中，Set接口有两个常用的实现类：HashSet和TreeSet...
set集合
移动开发记录
04-17 130
HashSet是无序的 TreeSet是可排序的 LinkedHashSet是排序的 Set接口 Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。 Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不 会接受这两个对象。 HashSet HashSet...
java中set集合_Java中的Set集合
weixin_39822184的博客
02-19 222
Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合里面，则添加操作失败，add()方法返回false，且新元素不会被添加入。1.HashSet是Set的接口的典型实现，大多数时候使用Set集合就是使用这个实现类，HashSet按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。HashSet具有以下特点，不能保证元素的排列顺序，可能和添加的顺序不同；HashS...
Java中的Set集合简单汇总解析
08-25
Java中的Set集合简单汇总解析 Set接口简介： Set接口是Java集合框架中的一个重要接口，它继承自Collection接口，并没有对Collection接口进行功能上的扩充。Set接口的主要特点是元素无序，并且都会以某种规则保证...
Set集合BUG
06-14
修改头文件sysset.h ，使C++builder中Set集合类ToInt出错的问题解决
Python语言基础：set集合运用.pptx
05-03
Python中的set集合是一种非常实用的数据结构，它包含了不重复的元素且无特定顺序。set集合在数据处理中常用于去重、成员关系测试以及集合运算等场景。下面将详细讲解set集合的创建、添加元素、移除元素、计算元素个...
Redis Set 集合的实例详解
09-09
通过这些命令，你可以轻松地创建、操作和分析Redis中的Set集合，满足各种不同的应用场景。无论是在实现去重功能，还是在进行集合运算时，Redis Set都提供了一种强大且高效的数据管理方式。在实际应用中，根据具体...
python set集合使用方法解析
09-18
主要介绍了python set集合使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
利用Set集合去除List集合中重复元素、字符串中的重复子串
12-22
Set集合作为一种特殊的数据结构，它的特性使得它成为实现去重功能的理想选择。本文将深入探讨如何利用Set集合去除List集合中的重复元素以及字符串中的重复子串。 首先，让我们理解Set集合的基本特点： 1. **一次只...
java中Set集合保证元素一致性原理.md
09-11
HashSet集合保证元素一致性
set集合的基本特点,set集合底层去重原理,集合怎么进行排序
07-01
Set集合在Java编程语言中是一种基础且重要的数据结构，它主要特点是存储不重复的元素，且没有特定的插入顺序。接下来我们将深入探讨Set集合的基本特点、底层去重原理以及如何进行排序。 首先，让我们理解Set集合的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值