set的集合

最新推荐文章于 2023-06-15 00:01:23 发布
最新推荐文章于 2023-06-15 00:01:23 发布
阅读量109 收藏
点赞数
分类专栏： set的集合 文章标签： java eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67465673/article/details/125188611
版权

目录

思维导图

一.set集合特点&遍历方式

set集合的特点：不重复基本数据类型
&字符串常量 String str=“abc”;
&引用对象 String str = new String();
代码块：

package com.jiangwenjuan.set;

import java.util.HashSet;
import java.util.Iterator;

/**
 * set集合的特点
 * 	不重复,基本数据类型&String = "acb";  &String str = new String();
 * 
 * 
 * @author 蒋文娟
 *
 * @date 2022年6月8日 下午4:42:02
 */
public class Demo1 {
	public static void main(String[] args) {
		HashSet set = new HashSet<>();
		set.add("zs");
		set.add("ls");
		set.add("ww");
		set.add("老六");
		set.add("ls");
		System.out.println(set.size());
		
		System.out.println("========增强for==========");
		for (Object obj : set) {
			System.out.println(obj);
		}
		
		System.out.println("========迭代器==========");
		
		Iterator it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
	}

}

结果：

4
========增强for==========
ww
老六
ls
zs
========迭代器==========
ww
老六
ls
zs

二.set集合去重原理

set底层去重原理：
1.set去重底层原理是与对象的hashCode以及equals方法相关
2.判断重复元素的时候，是先比较hashCode值，在调用equals比较内容

①.set去重底层原理是与对象的hashCode以及equals方法相关

代码块：

package com.jiangwenjuan.set;

import java.util.HashSet;

/**
 * @author 蒋文娟
 *
 * @date 2022年6月8日 下午6:05:43
 */
public class Demo2 {
	public static void main(String[] args) {
		HashSet set = new HashSet<>();
		set.add(new Person("zs", 18));
		set.add(new Person("ls", 14));// distrinct 在我们手里的时候可以去重，在别人就不能
		set.add(new Person("ww", 24));// 用set去重
		set.add(new Person("老六", 22));
		set.add(new Person("zs", 18));
		System.out.println(set.size());
	}
}
class Person{
	private String name;
	private int 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;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public int hashCode() {
		System.out.println("===========hashCode===========");
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result ;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("===========equals===========");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

结果：

===========hashCode===========
===========hashCode===========
===========hashCode===========
===========hashCode===========
===========hashCode===========
===========equals===========
4

如果hashCode哪里返回的是1的话，结果为一样也为四：

===========hashCode===========
===========hashCode===========
===========equals===========
===========hashCode===========
===========equals===========
===========equals===========
===========hashCode===========
===========equals===========
===========equals===========
===========equals===========
===========hashCode===========
===========equals===========
4

②、判断重复元素的时候，是先比较hashCode值，在调用equals比较内容

package com.jiangwenjuan.set;

import java.util.HashSet;

/**
 * 	set底层去重原理
 * 	1.set去重底层原理是与对象的hashCode以及equals方法相关
 * 	2.判断重复元素的时候，是先比较hashCode值，在调用equals比较内容
 * 
 * @author 蒋文娟
 *
 * @date 2022年6月8日 下午6:05:43
 */
public class Demo2 {
	public static void main(String[] args) {
		HashSet set = new HashSet<>();
		set.add(new Person("zs", 18));
		set.add(new Person("ls", 14));// distrinct 在我们手里的时候可以去重，在别人就不能
		set.add(new Person("ww", 24));// 用set去重
		set.add(new Person("老六", 22));
		set.add(new Person("zs", 18));
		System.out.println(set.size());
	}
}
class Person{
	private String name;
	private int 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;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public int hashCode() {
		System.out.println("===========hashCode===========");
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return 1;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("===========equals===========");
//		if (this == obj)
//			return true;
//		if (obj == null)
//			return false;
//		if (getClass() != obj.getClass())
//			return false;
//		Person other = (Person) obj;
//		if (age != other.age)
//			return false;
//		if (name == null) {
//			if (other.name != null)
//				return false;
//		} else if (!name.equals(other.name))
//			return false;
		return true;
	}
	
}

③、这两个的区别就在于，一个是为4，一个为1

		set.add(new Person("zs", 18));
		set.add(new Person("ls", 14))；
		set.add(new Person("ww", 24));
		set.add(new Person("老六", 22));
		set.add(new Person("zs", 18));

原理1：第一个加进去时候不需要比较，当第二加进去的时候，就跟第一个比较一次，再第三个加进去的时候比较两次，以此类推，当第五个加进去的时候就比较四次了。
equals的判断要留下。

原理2：当hasCode为1的时候，equals也为true的时候，就判定为了一个元素。

底层的基础原理就两个：先调用hashCode的值，相等，在去比equals，如果hashCode都不相等，就不会去调用equals方法了。

@Override
	public int hashCode() {
		System.out.println("===========hashCode===========");
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return 1;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("===========equals===========");
//		if (this == obj)
//			return true;
//		if (obj == null)
//			return false;
//		if (getClass() != obj.getClass())
//			return false;
//		Person other = (Person) obj;
//		if (age != other.age)
//			return false;
//		if (name == null) {
//			if (other.name != null)
//				return false;
//		} else if (!name.equals(other.name))
//			return false;
		return true;
	}

三.set集合自然排序接口

①.需求：从xxx公司，拿到用户数据，需要根据用户的级别，进行会议座位的排序

张三 部门总监 1
李四 普通员工 3
王五 部门经理 2。。

现象：1.String默认是能够排序的
2.自定义的对象无法排序，报类型转换异常

实体类：

class Person implements Comparable<Person>{
	
	private String name;
	private int age;
	private int level;
	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;
	}
	
	public Person(String name, int age, int level) {
		super();
		this.name = name;
		this.age = age;
		this.level = level;
	}
	public int getLevel() {
		return level;
	}
	public void setLevel(int level) {
		this.level = level;
	}
	public Person() {
		// TODO Auto-generated constructor stub
	}
	@Override
	public int hashCode() {
		System.out.println("===========hashCode===========");
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return 1;
	}
	@Override
	public boolean equals(Object obj) {
		System.out.println("===========equals===========");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return this.level - o.level;
	}

代码块：

package com.jiangwenjuan.set;

import java.util.TreeSet;

/**
 *  set集合排序
 * @author 蒋文娟
 *
 * @date 2022年6月8日 下午6:52:23
 */
public class Demo3 {
	public static void main(String[] args) {
		
		/**
		 * 	张三	部门总监	1
		 * 	李四	普通员工	3
		 * 	王五	部门经理	2
		 * 	。。 
		 * xxxService.list(1);
		 * 
		 * 	现象：
		 * 	1.String默认是能够排序的
		 * 	2.自定义的对象无法排序，报类型转换异常
		 */
		
//		Exception in thread "main" java.lang.ClassCastException: 类型转换异常
//		com.jiangwenjuan.set.Person cannot be cast to java.lang.Comparable
//							这个Person的类不能强制转换为Comparable接口
		TreeSet set = new TreeSet<>();
		set.add(new Person("张三", 18, 1));
		set.add(new Person("李四", 24, 4));
		set.add(new Person("王五", 26, 2));
		set.add(new Person("老六", 20, 3));
		for (Object Object : set) {
			System.out.println(Object);
		}
	}
}

这里就已经按会议座位排序了，结果：

Person [name=张三, age=18, level=1]
Person [name=王五, age=26, level=2]
Person [name=老六, age=20, level=3]
Person [name=李四, age=24, level=4]

②.需求：按照年龄升序，打印出人员信息

主要是要修改实体类中重写的compareTo方法
实体类： 这里也按照了年龄和等级的比较

@Override
	public int compareTo(Person o) {
		int levelRes = this.level - o.level;
		return levelRes == 0 ? this.age - o.age:levelRes;
	}

代码块：多加了一个八戒

TreeSet set = new TreeSet<>();
		set.add(new Person("张三", 18, 1));
		set.add(new Person("李四", 24, 4));
		set.add(new Person("王五", 26, 2));
		set.add(new Person("老六", 20, 3));
		set.add(new Person("八戒", 18, 3));
		for (Object Object : set) {
			System.out.println(Object);
		}

结果为：

Person [name=张三, age=18, level=1]
Person [name=王五, age=26, level=2]
Person [name=八戒, age=18, level=3]
Person [name=老六, age=20, level=3]
Person [name=李四, age=24, level=4]

③.需求：按照用户的首字母排序以及上面两个需求，都要满足

set集合排序
1. java.lang.Comparable:自然排序 排序的规则是单一的，不能够应对复杂的变化的需求
2. java.util.comparator:比较器排序
专门用来做比较的

TreeSet set = new TreeSet<>(comparator)

实体类的实现implements Comparable<Person>把它注释掉，最后的compareTo也注释掉。

这里有的小问题那是因为代码问题：
代码块：

package com.jiangwenjuan.set;

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

/**
 * @author 蒋文娟
 *
 * @date 2022年6月8日 下午6:52:23
 */
public class Demo3 {
	public static void main(String[] args) {
		
		/**
		 * 	需求1：从xxx公司，拿到用户数据，需要根据用户的级别，进行会议座位的排序
		 * 
		 * 	需求2：
		 * 	按照年龄升序，打印出人员信息
		 * 	
		 * 	需求3：
		 * 	按照用户的首字母排序
		 */
		
//		Exception in thread "main" java.lang.ClassCastException: 类型转换异常
//		com.jiangwenjuan.set.Person cannot be cast to java.lang.Comparable
//							这个Person的类不能强制转换为Comparable接口
		TreeSet set = new TreeSet<>(new levelCompartor());
		set.add(new Person("张三", 18, 1));
		set.add(new Person("李四", 24, 4));
		set.add(new Person("王五", 26, 2));
		set.add(new Person("老六", 20, 3));
		set.add(new Person("八戒", 18, 3));
		for (Object Object : set) {
			System.out.println(Object);
		}
	}
	
	

	
}



class levelCompartor implements Comparator<Person>{

	@Override
	public int compare(Person o1, Person o2) {
		return o1.getLevel() - o2.getLevel();
	}
	
}

然而这里的结果是只有四个，那是因为代码问题：

Person [name=张三, age=18, level=1]
Person [name=王五, age=26, level=2]
Person [name=老六, age=20, level=3]
Person [name=李四, age=24, level=4]

怎么解决呢？就是按照我们之前的哪个写法一样的

class levelCompartor implements Comparator<Person>{

	@Override
	public int compare(Person o1, Person o2) {
		int levelRes = o1.getLevel() - o2.getLevel();
		return levelRes == 0?o1.getAge() - o2.getAge():levelRes;
	}
	
}

结果就出来了:

Person [name=张三, age=18, level=1]
Person [name=王五, age=26, level=2]
Person [name=八戒, age=18, level=3]
Person [name=老六, age=20, level=3]
Person [name=李四, age=24, level=4]

注意：这一种方式相较于其他的方式有什么优点，它能够针于对同样的一组数据，做不同的处理，什么意思呢，就是那么我的需求发生了变化，我要按照这个字母的方式去对比，那么我可以根据不同的需求只要改正一个地方就可以了，假如说：我的A模块要按照名字或者等级排序那么就只要写上面的代码就可以了，那么在另外一个地方就要看下面的代码块了。

四.set集合比较器排序

这些数据假如不来于你的数据库，来自别人的

set.add(new Person("zs", 18, 1));
set.add(new Person("ls", 24, 4));
set.add(new Person("ww", 26, 2));
set.add(new Person("laoliu", 20, 3));
set.add(new Person("bajie", 18, 3));

有一个菜单，用户管理、会议管理、档案管理。如果想实现这些需求
在这里插入图片描述

代码块，就只需要这样就可以了

TreeSet<Person> set = new TreeSet<>((x,y)-> x.getName().compareTo(y.getName()));

按照名字的排序结果：

Person [name=bajie, age=18, level=3]
Person [name=laoliu, age=20, level=3]
Person [name=ls, age=24, level=4]
Person [name=ww, age=26, level=2]
Person [name=zs, age=18, level=1]

代码块：

TreeSet<Person> set = new TreeSet<>((x,y)-> x.getAge() - y.getAge());

按照年龄排序结果：这里有少了一个怎么解决呢？

Person [name=zs, age=18, level=1]
Person [name=laoliu, age=20, level=3]
Person [name=ls, age=24, level=4]
Person [name=ww, age=26, level=2]

解决方法：

TreeSet<Person> set = new TreeSet<>((x,y)-> {
			int ageRes = x.getAge() - y.getAge();
			int leveRes = 0;
			if(ageRes == 0) {
				leveRes = x.getLevel() - y.getLevel();
			}
			else {
				return ageRes;
			}
			return leveRes;
		});

正确的结果：

Person [name=zs, age=18, level=1]
Person [name=bajie, age=18, level=3]
Person [name=laoliu, age=20, level=3]
Person [name=ls, age=24, level=4]
Person [name=ww, age=26, level=2]

只要改代码就可以了，不会写s的，不管你的需求怎么变，我们的可以进行有效的处理。这就是比较序排序

敢敢130
关注
  • 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集合
xy87940020的博客
06-11 1万+
Set集合 Set集合与Collection基本上完全一样，它没有提供任何额外的方法。实际上Set就是Collection，只是行为略有不同（Set不允许包含重复元素）。 Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加操作失败，add方法返回false，且新元素不会被加入。 Set判断两个对象相同不是使用==运算符，而是根据equals方法。 public class SetTest { public static void main(String[] ar
集合框架（set集合）
qiu_hyun的博客
07-05 1416
一、集合框架Set（HashSet哈希表存储、重复元素存储底层探究） 1、简介 ① 元素是无序（存入和取出的顺序不一定一致），元素不可以重复； ② 查看Api会发现，set集合的功能与Collection集合的功能是一致的（就方法调用而言）； ③ HashSet哈希表存储 HashSet存入重复元素 <1>同姓名同年龄视为同一个人 ，重复元素 从代码上看，equals方法没有被调用 ...
set集合的特点
云飞扬°的博客
05-06 1万+
set集合的特点 A:存入集合的顺序和取出集合的顺序不一致 B:没有索引 C:存入集合的元素没有重复 set接口的实现类常用的有HashSet和TreeSet类。语法格式如下： Set<String> set1 = new HashSet<String>(); Set<String> set2 = new TreeSe...
Set集合详解
最新发布
weixin_74268571的博客
06-15 7556
set集合的简介，它的特点和遍历方式。介绍了HashSet重复元素存储底层原理，LinkedHashSet,TreeSet排序方法，SortedSet获取集合值的方法
Set集合（超详解)
weixin_67150631的博客
06-28 1万+
set集合，hashset，treeset
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集合的创建、添加元素、移除元素、计算元素个...
Set集合详细讲解
m0_65725031的博客
06-29 2050
目录一.Set集合二.HashSet集合 foreach循环遍历迭代器遍历数组 三.TreeSet集合今天的学习就到这里啦。
【Python教程】类及对象教程
Python热爱者的博客
09-16 334
一、类创建 class Animal: def setName(self,name): self.name=name def getName(self): return self.name #创建动物猫的对象 cat=Animal() cat.setName("cat") #调用cat对象的属性name print(cat.name) #调用cat方法的getName方法 print(cat.getName()) #调用cat方法的getName方法 另
【Java Set】1.Set集合的详解
返璞归真
08-10 3081
一、Set Set注重独一无二的性质，该体系集合可以知道某物是否已经存在于集合中，不会存储重复的元素，用于存储无序（存入和取出的顺序不一定相同）元素，值不能重复 对象的相等性： 引用到堆上同一个对象的两个引用是相等的。如果对两个引用调用hashcode方法，会得到相同的结果，如果对象所属的类没有覆盖object的hashcode方法的话，hashcode会返回每个对象特有的序号（java是依据...
set集合
win_best的博客
01-15 1022
1、set集合下有：HashSet、TreeSet、EnumSet 2、其中HashSet下的LinkedHashSet是有序的，按照添加的顺序排列，TreeSet也是有序的，如果进行了指定的顺序进行排序，则按照指定顺序排序，否则按照默认顺序排序。 3、由于Set中的元素是不能重复的，因此要对equals方法和hashCode方法进行重写时要注意：如果equals返回true，hashCode
Set、Map、List三种集合的差别
热门推荐
二狗的博客
05-30 10万+
1.集合类型主要有3种：set(集）、list(列表）和map(映射)。 2.三者关系 3.Set set接口时Collection接口的一个子接口，是无序的，set中不包含重复的元素，也就是说set中不存在两个这样的元素a1.equals(a2)结果为true。又因为Set接口提供的数据结构是数学意义上的集合概念的抽象，因此他支持对象的添加和删除。 Set的接口继承Collectio...
JAVA基础知识之Set集合
weixin_30568715的博客
10-28 247
Set集合的基本特征是不记录添加顺序，不允许元素重复（想想是为什么）。最常用的实现类是HashSet. 本文将要介绍以下内容 HashSet类 HashSe的特征 HashSet的equals和hashCode LinkedHashSet的特征 TreeSet的特征 EnumSet的特征 HashSet类 HashSet类直接实现了Set接口， 其底层其实...
Set系列集合
weixin_43521028的博客
08-17 590
Set系列集合的简述及使用 一.HashSet集合 特点: 添加的元素，是无序，不重复，无索引的。 代码演示: public class HashSetDemo01 { public static void main(String[] args) { // 无序，不重复，无索引的。 Set<String> sets = new HashSet<>(); // 一行经典代码！！ sets.add("Mybatis");
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值