2020.8.6Set集合

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

Set集合

定义：

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和
e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象

Set集合特点：元素唯一，不包含也不重复但是是无序集合
Set3个子类集合
HashSet底层数据结构是哈希表（JDK1.7 数组+链表 JDK1.8 优化 数组+链表+红黑树）
LinkedHashSet
TreeSet

01_HashSet

特点：元素唯一

HashSet概述

当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，
然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
HashSet 集合判断两个元素相等的标准：
两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。

结论:HashSet 保证元素唯一性是靠元素重写hashCode()和equals()方法来保证的，如果不重写则无法保证。
 @Override
 public int hashCode() {
 // return 0;
 // 因为成员变量值影响了哈希值，所以我们把成员变量值相加即可
	 // return this.name.hashCode() + this.age;
	// 看下面
	 //s1:name.hashCode()=40,age=30
	 //s2:name.hashCode()=20,age=50
	//尽可能的区分,我们可以把它们随变乘以一些整数
	 return this.name.hashCode() + this.age * 15;
 }

HashSet集合保证元素的唯一性，是靠元素重新hashCode和equals()方法来保证的，如果元素不重写，则无法保证元素的 唯一性。

案例演示

package SetDemo01;

import java.util.HashSet;

public class SetTest01 {
    public static void main(String[] args) {
        //Set集合特点：元素唯一，不包含也不重复
        HashSet<String> string = new HashSet<>();
        string.add("詹姆斯");
        string.add("韦德");
        string.add("安东尼");
        string.add("保罗");
        string.add("詹姆斯");
        string.add("韦德");
        string.add("安东尼");
        //遍历
        for (String str:string) {
            System.out.print(str+"\t");//保罗    詹姆斯    韦德 安东尼
        }

        HashSet<Integer> set2 = new HashSet<>();
        set2.add(200);
        set2.add(200);
        set2.add(200);
        set2.add(200);
        set2.add(200);
        set2.add(100);
        set2.add(300);

        System.out.println(set2);//    [100, 200, 300]

    }
}

HashSet 底层用的HashMap 这个集合来存的

合理的重写hashCode方法，为了减少equals()方法的调用次数，也就是说为了减少碰撞。

案例演示1：student

package SetDemo01;

import java.util.Objects;

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

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

测试类

package SetDemo01;

import java.util.HashSet;

public class SetTest02 {
    public static void main(String[] args) {
        //HashSet 底层用的HashMap 这个集合来存的
        //合理的重写hashCode方法，为了减少equals()方法的调用次数，也就是说为了减少碰撞。
        HashSet<Student> hashSet = new HashSet<>();
        hashSet.add(new Student("詹姆斯", 35));
        hashSet.add(new Student("韦德", 34));
        hashSet.add(new Student("安东尼", 32));
        hashSet.add(new Student("韦德", 34));
        hashSet.add(new Student("安东尼", 32));
        hashSet.add(new Student("保罗", 30));
        //遍历集合
        for (Student list : hashSet) {
            System.out.println(list);
        }
    }
}

02_LinkedHashSet

数据结构 有两个 链表和哈希表
 链表保证有序 哈希表保证元素唯一

LinkedHashSet 元素有序，且唯一，底层数据结构是链表+哈希表 链表保证元素有序，哈希表保证元素唯一

package LinkedHashSetDemo01;

import java.util.LinkedHashSet;

public class LinkedHashSetTest01 {
    public static void main(String[] args) {
        //LinkedHashSet 元素有序，且唯一，底层数据结构是链表+哈希表 链表保证元素有序，哈希表保证元素唯一
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(100);
        linkedHashSet.add(100);
        linkedHashSet.add(100);
        linkedHashSet.add(200);
        linkedHashSet.add(300);
        linkedHashSet.add(400);

        for (Integer integer : linkedHashSet) {
            System.out.println(integer);
        }
    }
}

03_TreeSet

TreeSet集合的特点: 元素唯一,并且可以对元素进行排序

排序:
	a:	自然排序
	b:    使用比较器排序
	到底使用的是哪一种的排序取决于,构造方法.

注意：使用TreeSet集合进行元素的自然排序，那么对元素有要求，要求这个元素
必须实现Comparable接口 否则无法进行自然排序

03.1_TreeSet保证元素唯一和自然排序的原理和图解

TreeSet保证元素唯一和自然排序的原理和图解
             二叉树的数据结构 先存入一个树根 分两个叉
	 存储元素时 跟树根比较 小的放在左边 大的放在右边
	 如果相等就不存储
	 取的时候按照 左中右的顺序来取

案例演示：创建TreeSet

package TreeSetDemo01;

import java.util.TreeSet;

public class TreeSetTest01 {
    public static void main(String[] args) {
        //TreeSet 底层数据结构是二叉树，元素唯一，且能对元素进行排序。
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(20);
        treeSet.add(18);
        treeSet.add(23);
        treeSet.add(22);
        treeSet.add(17);
        treeSet.add(24);
        for (Integer integer : treeSet) {
            System.out.print(integer+"\t");//17    18 20 22 23 24
        }
    }
}

案例演示：实现了Comparable重写了 compareTo（自然排序）

package TreeSetDemo01;

import java.util.Objects;

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

    public Student() {
    }

    public Student(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

    @Override
    public int compareTo(Student s) {
     /*   //按照年龄大小来排序
        int num=this.age-s.age;//两个年龄相减，如果为0，就比较姓名
        int num1=num==0?this.name.compareTo(s.name):num;
        return num1;
*/
     //按照姓名长度排序
        int num=this.name.length()-s.name.length();
        //比较姓名内容
        int num1= (num == 0) ? this.name.compareTo(s.name):num;
        //比较年龄
        int num2=num1==0?this.age-s.age:num1;
        return num2;
    }
}

测试类

package TreeSetDemo01;


import java.util.TreeSet;

//TreeSet的两种排序
//自然排序：采用空参构造， 自然排序对元素有要求，要求元素必须实现一个Comparable 接口 重写 compareTo(T o);
//根据compareTo(T o);的返回值的 正 负 0 来决定元素在二叉树中放置左右的位置
public class TreeSetTest02 {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(new Student("勒布朗詹姆斯aa", 35));
        treeSet.add(new Student("布朗尼詹姆斯aaaaa", 15));
        treeSet.add(new Student("詹姆斯哈登a", 30));
        treeSet.add(new Student("詹姆斯哈登a", 30));
        treeSet.add(new Student("安东尼戴维斯aaaaaaa", 26));
        treeSet.add(new Student("安东尼戴维斯sfsdg", 26));
        treeSet.add(new Student("贾维尔戴维斯vdfgd", 26));
        treeSet.add(new Student("贾维尔戴维斯asffw", 22));

        //按照学生的年龄大小来排序
        for (Student student : treeSet) {
            System.out.println(student.getName()+"=="+student.getAge());
        }
        //按照姓名长度来排序
    }
}

注意：自然排序 此对象 必须实现Comparable接口 否则报错

案例演示：比较器排序

package TreeSetDemo01;

import java.util.Objects;

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

    public Student1() {
    }

    public Student1(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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student1 student1 = (Student1) o;
        return age == student1.age &&
                Objects.equals(name, student1.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

}

测试类

package TreeSetDemo01;

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

public class ComparatorTest02 {
    public static void main(String[] args) {
        //TreeSet 排序方式2：比较器排序 ，使用有参构造。
       /* TreeSet(Comparator < ? super E > comparator)
        构造一个新的空 TreeSet，它根据指定比较器进行排序。

        Comparator 比较器
        */
        //比较器排序
        TreeSet<Student1> treeSet = new TreeSet<>(new myComparator());
        treeSet.add(new Student1("勒布朗詹姆斯aa", 35));
        treeSet.add(new Student1("布朗尼詹姆斯aaaaa", 15));
        treeSet.add(new Student1("詹姆斯哈登a", 30));
        treeSet.add(new Student1("詹姆斯哈登a", 30));
        treeSet.add(new Student1("安东尼戴维斯aaaaaaa", 26));
        treeSet.add(new Student1("安东尼戴维斯sfsdg", 26));
        treeSet.add(new Student1("贾维尔戴维斯vdfgd", 26));
        treeSet.add(new Student1("贾维尔戴维斯asffw", 22));
        for (Student1 student1:treeSet) {
            System.out.println(student1);
        }
    }
}
class myComparator implements Comparator<Student1>{


    @Override
    public int compare(Student1 s1, Student1 s2) {
        //按年龄大小来排序
        int num=s1.getAge()-s2.getAge();
        int num1=num==0?s1.getName().compareTo(s2.getName()):num;

        return num1;
    }
}

案例演示1：使用匿名内部类进行传参

package TreeSetDemo01;

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

//比较器排序
public class ComparatorTest01 {
    public static void main(String[] args) {
        /*使用匿名内部类来传参*/
        TreeSet<Student1> treeSet = new TreeSet<Student1>(new Comparator<Student1>() {
            @Override
            public int compare(Student1 s1, Student1 s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        treeSet.add(new Student1("勒布朗詹姆斯aa", 35));
        treeSet.add(new Student1("布朗尼詹姆斯aaaaa", 15));
        treeSet.add(new Student1("詹姆斯哈登a", 30));
        treeSet.add(new Student1("詹姆斯哈登a", 30));
        treeSet.add(new Student1("安东尼戴维斯aaaaaaa", 26));
        treeSet.add(new Student1("安东尼戴维斯sfsdg", 26));
        treeSet.add(new Student1("贾维尔戴维斯vdfgd", 26));
        treeSet.add(new Student1("贾维尔戴维斯asffw", 22));
        for (Student1 student1 : treeSet) {
            System.out.println(student1);
        }
    }
}

案例演示2：

package TreeSetDemo01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;

public class ComparatorTest03 {
    //数组使用比较器排序
    //匿名内部类来传参
    public static void main(String[] args) {
        Integer[] arr = {99, 23, 32, 45, 10, 20, 30, 40};
        //sort排序方法
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {

                return a - b;
            }
        });
        System.out.println(Arrays.toString(arr));//[10, 20, 23, 30, 32, 40, 45, 99]
        //集合用法
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(23);
        list.add(22);
        list.add(29);
        list.add(1);
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(list);//[1, 2, 22, 23, 29]
    }
}
有点。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Python3学习笔记】之【Python基础——集合】
AA8j的博客
09-05 205
集合（set）是一个无序的不重复元素序列。 可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。 注意：集合输出时不会输出相同元素。 创建格式： set1 = {1, 2, 3} set2 = {} print(set1) print(set2) {1, 2, 3} {} 增删 增 set1 = {1, 2, 3} list1 = (5, 6, 7) set1.add(4) print(set1) set1
Set集合相关20200917
m0_46281234的博客
09-17 102
1，Set集合，继承自Collection，不包含重复的元素。没有带索引的方法，所以不能使用普通for循环。而进行遍历时，不一定按照顺序取值。 2，哈希值是jdk通过字符串或者数值或者对象的地址经过运算得到的一个整型的数值。默认情况下，不同对象的哈希值是不相同的，但是通过在类中对哈希值进行重写，可以实现哈希值相同的情况。 ...
【Redis缓存机制】6.Set集合类型操作使用
有趣的人生 一半是山川湖海 一半是初心情怀
07-10 223
Set集合类型 (1)介绍 redis的set是string类型的无序集合 set元素最大可以包含(2的32次方-1)个元素 关于set集合类型除了基本的添加删除操作，其它有用的操作还包含集合的取并集(union)，交集(intersection)，差集(difference)。通过这些操作可以很容易的实现类似好友推荐的功能。 注意:每个集合中的各个元素不能重复。 (2)操作 sadd key...
6.2set用法
kopoo的博客
09-27 264
目录 1.set的定义 2.set容器内元素的访问 3.set常见使用的函数 set可以内部进行自动递增排序，且自动去除了重复元素 1.set的定义 set<typename> name; set<typename> a[100]; 2.set容器内元素的访问 set<typename>::iterator it; 可以得到迭代器it ...
6.SET与GET
小黑的博客
09-15 122
GET、SET 因为对所有的属性都要进行赋值和取值，系统制定了一套默认的规则----&gt;get、set方法 set-----&gt;赋值 有参无返回值 get-----&gt;取值 无参有返回值 GET 构成：修饰词 返回值 方法名（参数列表）{ 方法体 返回值 } 修饰词：一般是public 返回值：类型于成员变量类型一致 方法名： get + 对应...
Redis-Desktop-Manager-for-Windows-2020.6.0.0.zip
11-30
这款2020.6.0.0版本是针对Windows操作系统的一个安装包，适用于2020年11月30日更新的最新版本。在本文中，我们将深入探讨Redis Desktop Manager的功能特性、如何安装与使用，以及与Redis数据库相关的知识。 Redis是...
最新版windows redis-desktop-manager-2020.3.zip
09-14
Redis Desktop Manager 2020.3是一款专为Windows用户设计的图形化界面工具，用于管理和操作Redis数据库。Redis，全称Remote Dictionary Server，是一种开源的、基于键值对的数据存储系统，常被用作数据库、缓存以及...
redis-desktop-manager-2020.1.0
07-25
支持多种数据类型，如字符串（String）、哈希表（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。 3. **命令行接口**：内置了命令行工具，用户可以直接在界面上执行Redis命令，进行复杂的数据操作和...
redis-desktop-manager-2020.2.0.0.rar
08-30
8. **版本兼容性**：确保工具与你正在使用的Redis版本兼容至关重要，例如，2020.2.0.0版本可能适用于Redis的某个特定版本范围。 9. **安全性**：在使用远程连接时，确保使用安全的网络环境，避免密码泄露和其他安全...
2020.4.8美团安卓开发暑期实习一面面经
12-21
7. **反射中的方法**：通过`Field`类的`set`方法可以改变对象的私有字段，如`field.set(obj, value)`。 8. **哈希码（hashCode）**：哈希码是一个整数，用于快速定位对象在哈希表中的位置。对象的`hashCode()`方法...
6.set 集合类型
jasmine777的博客
11-05 373
set 集合是一个无序且元素不重复的集合数据类型 set 集合使用 大括号{} 或者set()方法来定义 如果需要定义一个空集合时，只能使用set()方法，因为大括号时定义的空字典 集合重要用于运算、交集、差集、并集、对称集合 #集合的定义方式 vars = {1,2,3,'a','b',1,2} print(vars,type(vars)) #输出结果为 {1, 2, 3, 'b', 'a'} <class 'set'> set：集合 var..
SE6新特性之集合Set、Map、WeakSet和WeakMap详解
小红帽的博客
04-30 7389
SE5的时候我们经常用数组或者类数组对象来操作数据，而对于一些使用惯了java之类语言的集合的开发人员来说，总有少了点什么的感觉，SE6提供Set和Map这两个集合。不仅从根本上为一些问题提供了解决方案(如数据不重复)，还大大提升了性能。 要想理解Set和Map，就要从它的根本问题说起，在进行详细的API概览之前，我觉得有必要先说明两点： 遍历Set和Map的顺序就是元素插入的顺序。这
2020.8.2正则表达式
weixin_46669997的博客
08-03 401
01_正则表达式 01.1_定义：就是，描述这些规则的语法 正则表达式不能独立使用，它只是一种用来定义字符串的规则模式，必须在相应的正则表达式方法中应用，才能实现对字符串的匹配、查找、替换及分割等操作。 案例演示：用非正则表达式实现 package RegxDemo01; import java.util.Scanner; //正则表达式 public class RegxTest01 { public static void main(String[] args) { /* 校验
2020.8.27网络编程、UDP协议
weixin_46669997的博客
08-28 324
01网络编程 01.1_计算机网络 概述：是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来。 其实就是在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 网络编程就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换 01.2_网络模型： OSI（Open System Interconnection开放系统互连）七层参考模型 TCP/IP四层参考模型 主机至网络层(物理层 , 数据链路层) 网际层 传输层 应用层(应用
2020.8.8LinkedHashMap、TreeMap、集合嵌套
weixin_46669997的博客
08-08 293
01_LinkedHashMap 键的数据结构是列表和哈希表，键有序且唯一。列表保证有序哈希表保证唯一。 案例演示 package LinkedHashMapDemo; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; public class LinkedHashMapTest01 { public static void mai
2020.8.6可变参数、转换数组、集合嵌套
weixin_46669997的博客
08-06 255
01_可变参数 可变参数概述:定义方法的时候不知道该定义多少个参数 格式:修饰符 返回值类型 方法名(数据类型… 变量名){} 注意事项 这里的变量其实是一个数组 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个 案例演示： package VariableDemo01; //可变参数 public class VariableTest01 { public static void main(String[] args) { int sum=add(1,2)
2020.8.20多线程-三种创建线程及方法
weixin_46669997的博客
08-20 208
01_多线程 01.1_进程 概念：进程就是正在运行的程序，是系统进行资源分配和调用的独立单位。 每一个进程都有它自己的内存空间和系统资源。 多进程 单进程计算机只能做一件事情。而我们现在的计算机都可以一边玩游戏(游戏进程),一边听音乐(音乐进程)， 01.2_线程 在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。是程序使用CPU的基本单位。所以，进程是拥有资源的基本单位， 线程是CPU调度的基本单位。 多线程 多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。 用一个生
2020.8.10异常
weixin_46669997的博客
08-10 190
01_异常 定义：异常就是Java程序在运行过程中出现的错误。 异常的基类（所有异常或这错误的超类）:Throwable问题 Error错误，属于严重性问题,用于指示合理的应用程序不应该试图捕获的严重问题。() Exception异常，属于一般性 运行期异常:RuntimeException及其子类可以选择解决，也可以不解决 编译期异常:发生在编译期间。非RuntimeException及其子类，编译期异常必须解决，不解决程序无法运行。 01.1_运行期异常 对于运行期异常，我们
2020.8.25线程池、定时器、三个设计模式
weixin_46669997的博客
08-28 187
01_线程池 概述：程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。 线程池的特点：线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。 线程池的方法 public static ExecutorService newCachedThreadPool(): 根据任务的数量来创建线程对应的线程个数 public static Execu
2020 Java面试精华：基础语法与难点解析
- 集合框架是Java的核心组成部分，包括List、Set、Map等接口及其实现类，面试时可能会考察数组、ArrayList、LinkedList、HashMap、TreeMap等的特性和使用场景。 8. **输入/输出流（I/O）**： - I/O操作涉及文件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

有点。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值