JavaSE十二（Set）

最新推荐文章于 2022-08-20 13:51:17 发布
最新推荐文章于 2022-08-20 13:51:17 发布
阅读量1.6k 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46002941/article/details/109157361
版权

文章目录

Set

3.1 Set集合的概述和特点

Set集合的特点

  • 不包含重复元素的集合
  • 没有带索引的方法，所以不能使用普通for循环遍历

Set集合练习

  • 存储字符串并遍历
/*
	Set集合特点
			不包含重复元素的集合
			没有带索引的方法，所以不能使用普通for循环
	HashSet：对集合的迭代顺序不作任何保证
 */
public class SetDemo {
	public static void main(String[] args) {
		//创建集合对象
		Set<String> set = new HashSet<String>();
		//添加元素
		set.add("hello");
		set.add("world");
		set.add("java");
		//不包含重复元素
		set.add("hello");
		//遍历
		for (String s : set){
			System.out.println(s);
		}
		System.out.println("-------------");
		//迭代器遍历
		Iterator<String> it = set.iterator();
		while (it.hasNext()){
			String next = it.next();
			System.out.println(next);
		}
	}
}

3.2 哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值

  • public int hashCode()：返回对象的哈希码值

对象的哈希值的特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
		//创建学生对象
		Student s = new Student("张三",11);

		//同一个对象多次调用hashCode()方法返回的哈希值是相同的
		System.out.println(s.hashCode());//460141958
		System.out.println(s.hashCode());//460141958
		System.out.println("-------");

		Student s2 = new Student("李四",33);
		//默认情况下，不同对象的哈希值是不一样的
		//通过方法重写，可以实现不同对象的哈希值是相同的
		System.out.println(s2.hashCode());//1163157884

3.3 HashSet集合的概述和特点

HashSet集合特点

  • 底层数据结构是哈希表
  • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的顺序是一致的
  • 没有带索引的方法，不能使用普通for循环遍历
  • 由于是Set集合，所以是不包含重复元素的

HashSet集合练习

  • 储存字符串并遍历
public class HashSetDemo {
	public static void main(String[] args) {
		HashSet<String> hashSet = new HashSet<String>();
		hashSet.add("hello");
		hashSet.add("world");
		hashSet.add("java");
		hashSet.add("java");
		for (String s : hashSet){
			System.out.println(s);
		}
		System.out.println("----------");
		Iterator<String> it = hashSet.iterator();
		while (it.hasNext()){
			String next = it.next();
			System.out.println(next);
		}
	}
}

3.4 HashSet集合保证元素唯一性源码分析

在这里插入图片描述

3.5 常见数据结构之哈希表

在这里插入图片描述

案例：HashSet集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合

​ 要求：学生成员变量值相同，我们就认为是同一个对象

思路：

  1. 定义学生类

  2. 创建HashSet集合对象

  3. 创建学生对象

  4. 把学生对象添加到集合

  5. 遍历集合对象（增强for）

  6. 在学生类中重写两个方法

    1. ​ hashCode()和euqals()

      ​ 自动生成即可，否则无法保证唯一性。

3.6 LinkedHashSet集合概述和特点

LinkedHashSet集合特点

  • 哈希表和链表实现的Set接口，具有可预测的 迭代次序
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是说没有重复元素

LinkedHashSet集合练习

  • 存储字符并遍历

3.7 TreeSet集合概述和特点

TreeSet集合特点

  • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体的排序方法取决于构造方法
    • TreeSet():根据其元素的自然排序进行排序
    • TreeSet(Comparator comparator):根据指定的比较器进行排序
  • 没有带索引的方法，所有不能使用普通for循环进行遍历
  • 由于是Set集合，所以不包含重复元素的集合

TreeSet集合练习

  • 存储整数并遍历
public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet<Integer> treeSet =  new TreeSet<Integer>();
		treeSet.add(5);
		treeSet.add(1);
		treeSet.add(3);
		treeSet.add(4);
		treeSet.add(2);

		treeSet.add(2);
		for (Integer i : treeSet){
			System.out.println(i);
		}
	}
}
----------
1
2
3
4
5

3.8 自然排序Comparator的使用

  • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  • 要求：按照年龄从小到大排序，年龄相同 时，按照姓名的字母排序

结论：

  • 用 TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
  • 自然排序，就是让元素所属的类实现Comparator接口，重写compareTo(To)方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

以下是自然排序类实现Comparable接口方法：

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 int compareTo(Student s) {
		//return 0;//结果只会存储第一个
		//return 1;//按照存储顺序排序
		//return -1;//按照存储顺序倒序排列
		//按照年龄从小到大排序
		int num = this.age - s.age;
		//return num;

		//年龄相同时按照字母顺序排序
		int num2 = num == 0 ? this.name.compareTo(s.name):num;
		return num2;
	}
}

/*
	- 存储学生对象并遍历，创建TreeSet集合使用**无参构造方法**
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母排序
 */
public class TreeSetDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		TreeSet<Student> ts = new TreeSet<Student>();

		//创建学生对象
		Student s1 = new Student("xishi",11);
		Student s2 = new Student("diaocan",14);
		Student s3 = new Student("wangzhaojun",4);
		Student s4 = new Student("yangyuhuan",21);
		Student s5 = new Student("yngyuhuan",21);
		Student s6 = new Student("angyuhuan",21);
		//添加学生对象到集合中
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		//ava.lang.ClassCastException: com.TreeSet.Student cannot be cast to java.lang.Comparable此时必须对象所属的类
		// 实现Comparator接口并重写compareTo(To)方法
		//遍历
		for (Student s : ts){
			System.out.println(s.getName()+","+s.getAge());
		}
	}
}
------------------------
wangzhaojun,4
xishi,11
diaocan,14
angyuhuan,21
yangyuhuan,21
yngyuhuan,21

3.9 比较器Comparator排序的使用

  • 存储学生对象并遍历
  • 要求按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
public class ComparatorDemo {
	public static void main(String[] args) {
		//创建集合对象
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				//this.age - s.age
				//s1, s2
				int num1 = s1.getAge() - s2.getAge();
				int num2 =num1== 0 ? s1.getName().compareTo(s2.getName()) : num1;
				return num2;
			}
		});
		//创建学生对象
		Student s1 = new Student("zhangsan",32);
		Student s2 = new Student("lisi",42);
		Student s6 = new Student("lisi",42);
		Student s7 = new Student("lisi",3);

		Student s3 = new Student("wangwu",15);
		Student s4 = new Student("chenliu",22);
		Student s5 = new Student("ahenliu",22);

		//向集合中添加元素
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		ts.add(s7);

		//遍历集合
		for (Student s : ts){
			System.out.println(s.getName()+","+s.getAge());
		}
	}
}
-------------------------
运行结果：
		lisi,3
        wangwu,15
        ahenliu,22
        chenliu,22
        zhangsan,32
        lisi,42

结论

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序 对元素进行排序的
  • 用比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写Compare(T o1,T o2)方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

案例：成绩排序

需求：用TreeSet集合存储多个学生信息（姓名，语文成绩，数学成绩），并遍历该集合
要求：按照总分从高到底出现

思路：

  1. 定义学生类
  2. 创建TreeSet集合对象，通过比较器排序进行排序
  3. 创建学生对象
  4. 把学生对象添加到集合
  5. 遍历集合

比较器排序

public class TreeSetDemo {
	public static void main(String[] args) {
		//创建TreeSet集合对象
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				//int num = (s2.getMathGrade() + s2.getChinese()) - (s1.getChinese() + s1.getMathGrade());
				//主要条件
				int num = s2.getSum() - s1.getSum();
				//次要条件
				int num2 = num == 0 ? s1.getChinese() - s2.getChinese()  : num;
				int num3 = num2==0?s1.getName().compareTo(s2.getName()):num2;
				return num3;
			}
		});

		//创建学生对象
		Student s1 = new Student("aaa", 100, 80);
		Student s2 = new Student("wgwe", 63, 74);
		Student s3 = new Student("age", 64, 93);
		Student s4 = new Student("betw", 95, 99);
		Student s5 = new Student("ggag", 90, 90);
		Student s6 = new Student("ggag", 95, 99);
		//添加学生对象到集合
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		//增强for遍历
		for (Student s : ts) {
			System.out.println(s.getName() + "," + s.getMathGrade() + "," + s.getChinese() + "," + s.getSum());
		}
	}
}
-----------
运行结果：
    betw,99,95,194
    ggag,99,95,194
    ggag,90,90,180
    aaa,80,100,180
    age,93,64,157
    wgwe,74,63,137

自然排序：

public class Student1 implements Comparable<Student1> {
	private String name;
	private int chinese;
	private int Math;

	public Student1() {
	}

	public Student1(String name, int chinese, int math) {
		this.name = name;
		this.chinese = chinese;
		Math = math;
	}

	public String getName() {
		return name;
	}

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

	public int getChinese() {
		return chinese;
	}

	public void setChinese(int chinese) {
		this.chinese = chinese;
	}

	public int getMath() {
		return Math;
	}

	public void setMath(int math) {
		Math = math;
	}
	public int getSum(){
		return chinese+Math;
	}

	@Override
	public int compareTo(Student1 s) {
        //主要条件
		int num = s.getSum() - this.getSum();
        //次要条件
		int num2 = num == 0?s.Math-this.Math:num;
		int num3 = num2==0?s.name.compareTo(this.name):num2;
		return num3;
	}
}
---------------------
package com.Test1;

import java.util.TreeSet;

public class TreeSetDemo2 {
	public static void main(String[] args) {
		//创建TreeSet集合对象
		TreeSet<Student1> ts = new TreeSet<Student1>();

		//创建学生对象
		Student1 s1 = new Student1("张三", 99, 100);
		Student1 s2 = new Student1("李四", 79, 100);
		Student1 s3 = new Student1("王五", 99, 93);
		Student1 s4 = new Student1("赵六", 99, 84);
		Student1 s5 = new Student1("陈柒", 84, 99);
		Student1 s6 = new Student1("二柒", 79, 100);
		//添加
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		//遍历
		for (Student1 s : ts) {
			System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath());
		}
	}
}
----------------
张三,99,100
王五,99,93
陈柒,84,99
赵六,99,84
李四,79,100
二柒,79,100

案例：不重复的随机数

需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出

思路：

  1. 创建Set集合对象
  2. 创建随机数对象
  3. 判断集合的长度是不是小于10
    1. 是：产生一个随机数，添加到集合
    2. 否：回到3继续
  4. 遍历集合
/*
	需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
 */
public class SetDemo {
	public static void main(String[] args) {
		//创建Set集合对象
		//Set<Integer> set = new HashSet<Integer>();
		Set<Integer> set = new TreeSet<Integer>();

		//创建随机数对象
		Random r = new Random();

		//判断集合是否小于10
		while (set.size() < 10) {
			//添加一随机数
			int i = r.nextInt(20)+1;
			//添加随机数到集合
			set.add(i);
		}
		//遍历集合
		for (Integer s : set) {
			System.out.println(s);
		}
	}
}
TryAgain-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
JDK12(JavaSEDevelopmentKit)12.0官方中文正式版Win64位
07-25
JDK12全称Java SE Development Kit 12目前已经正式发布了，新的Java JDK 12正式版中存在两套 64 位 ARM 实现，主要存在于 src/hotspot/cpu/arm 和 open/src/hotspot/cpu/aarch64 目录。两者都实现了 aarch64，现在将只保留后者，删除由 Oracle 提供的 arm64。这将使贡献者将他们的精力集中在单个
JavaSE 12
cystart的博客
02-02 138
方法的重写(override / overwrite) 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。 3. 重写的规定： 方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{ //方法体 } 约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法 ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同 ②
Java SE 12 新增特性
JHIII的博客
08-20 195
case "banana", "Banana" -> System.out.println("香蕉");case "september", "october", "november" -> "秋天";case "december", "january", "february" -> "冬天";case "june", "july", "august" -> "夏天";case "march", "april", "may" -> "春天";这是一种便于人类阅读的格式，如 "2M "或 "30亿"。
JAVA SE (12)
zzyssg的博客
04-03 429
–> JAVA SE (11) java的集合类，，存放的是对象的引用，而非对象的本身。 集合类型主要有3种：set(集)、list(列表)、map(映射) 集合 集合框架特点： 高性能，基本集合（数组、链表、哈希表、树）的实现是高效的 允许不同的类型的集合以相似的方式工作 对一个集合的扩展是简单的 因此，整个框架围绕一组标准接口设计。 java集合框架主要包括两种类型的容器： Col...
JavaSE 12（打怪升级ing）
weixin_45333967的博客
07-31 292
前言： 继续在Leetcode的题海里畅游,领教新题型，新方法，新思路，并且把它们整理出来，便于自己的复习与巩固。 1. 1.思路及步骤： 2.编程代码及运行结果： 总结： 准确且充分的利用题目给出的信息从而解决问题。 ...
JavaSE专题-Set集合.doc
06-03
JavaSE专题-Set集合 Set集合是JavaSE中的一种重要数据结构，主要包括HashSet、TreeSet和LinkedHashSet三个子类。下面我们将对Set集合的原理、特点、使用场景等进行详细的探索和分析。 HashSet HashSet是Set集合中...
JavaSE_JavaSE学习资料_
10-02
集合框架是Java处理对象集合的重要工具，包括List、Set、Map接口以及它们的实现类，如ArrayList、LinkedList、HashSet、HashMap等。学习集合框架能够帮助开发者有效地组织和管理数据，实现数据的存储、查找和操作。...
王道JavaSE阶段测试
05-31
4. **集合框架**：ArrayList，LinkedList，HashSet，HashMap等容器的理解与使用，泛型，迭代器，List与Set的区别，Map接口及其实现类的特点。 5. **IO流**：字节流与字符流，缓冲流，对象序列化，文件操作，输入...
javase笔记.7z
05-24
Java集合框架是处理对象数组的一种方式，包括List、Set、Queue等接口，以及ArrayList、HashSet、LinkedList等实现类。此外，HashMap和TreeMap等提供了键值对存储功能。 五、IO流 Java的IO流体系提供了处理输入输出...
javaSE（12）（集合大总结）
咸蛋超人
11-29 660
1.数据结构： 数据结构是底层的东西，可以让人对知识理解的更透彻，实际开发中也可能用到。常见的数据结构有线性表，链表，栈，队列，树。线性表（顺序存储和链式存储），栈（后进先出），队列（先进先出）。数据结构有时间一定要再看看。 2.在以后的实际开发中，经常会遇到一个问题：需要存储N个自定义类型的对象，即：（1）数量不确定。（2）存储的是对象。数组可以存储对象但是数量必须实现确定。 3.为了弥补数
JAVASE12
cnjss的博客
04-08 140
JAVASE12 一、 IO流中的功能流 1、缓冲流 格式：功能流（节点流）； 首先我们来介绍缓冲流： 缓冲流可以增强节点流的读写效率，并且能提高节点流的性能 //字节流是没有新增方法的，我们可以使用多态 BufferedInputStream //字节输入流缓冲流 BufferedInputStream(InputStream)//格式 BufferedOutputStream //字节输出流缓冲流 BufferedOutputStream(OutputStream)//格式 //字符流有新增方法，不
JAVAse12
xiaosagepblog的博客
12-10 137
GSDFHSH十多个
JavaSE12
weixin_42367504的博客
03-10 85
Java常用的类（二） String类 字符串是常量，创建之后不改变 字符串字面值存储在字符串池中，字符串池存储在方法区，可以共享 String name=“Hello”：产生一个对象，存储在字符串常量池中 String name=new String(“Hello”)：产生两个对象，堆、池中各存储一个，如果常量池中没有该值，否则只在堆中创建，栈中的name只指向堆中的“Hello”对象 String name="Hello";// 存储在常量池 name="张三";//常量池中的"张
javaSE-第12篇-java加载与执行
java孤独求败的博客
03-07 268
第一步:编写java源文件，注意后缀名是java，如:Hello.java 第二步:编译 也就是检查java语法格式，当编译成功，则自动生成一个字节码文件(.class)，如Hello.class 当编译失败时，则改错然后重新编译 使用javac命令编译 Hello.java 第三步: 运行的是字节码文件 注意:想当在当前操作系统上运行字节码文件，则必须保证有JVM JVM:java ...
JavaSE12:集合简单总结
deserts的博客
07-15 293
累了困了，就来学HashMap
JavaSE-12 【集合】
Allure泽宇的博客
05-19 710
Java集合的基本操作
Java_SE12-XML
Lh_0618的博客
04-12 406
XML基本语法 常用于简化数据的存储和共享 *元素是指从开始标签到结束标签的部分,元素可以拥有属性 *属性提供关于元素的额外信息,通常提供不属于数据组成部分的信息,但是对需要处理这个元素的应用程序来说却很重要，属性必须加引号,属性值必须被引号包围,不过单引号和双引号均可使用，如果属性值本身包含双引号,那么有必要使用单引号包围它,或者可以使用实体引用 严格区分大小写 XML解析方式1**重点内容
JavaSE12—窗体程序开发（上）
insswer之家
04-29 241
JavaSE12—窗体程序开发（上） 1. JFrame窗体 JFrame类定义了生成窗体的模板，每实例化一个窗体类，就产生了一个窗体。创建窗体后，可以像窗体添加组件，同时为组件添加时间监听器，处理一些最大化，最小化，关闭，调整大小等窗体事件。 定义自己的窗体，最常用的方法就是继承JFrame类并扩展为自己的窗体类，这个扩展的窗体类应该定义好窗体的界面和事件监听以及所有业务处理方法。 ...
JavaSE深度解析：Set集合探秘
"本文档主要探讨JavaSE中的Set集合，包括HashSet、TreeSet和LinkedHashSet的存储特点、原理以及使用方法。" 在Java编程语言中，Set接口是Collection接口的一个子接口，它代表了一组不包含重复元素的集合。Set集合的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值