java中Set集合

最新推荐文章于 2024-03-30 21:10:29 发布
最新推荐文章于 2024-03-30 21:10:29 发布
阅读量585 收藏
点赞数
分类专栏： java基础 文章标签： java
@TMQ
本文链接：https://blog.csdn.net/weixin_42076050/article/details/105380319
版权

三.Set

特点： 无序的（放入与输出的顺序不一致）， 不可重复

1.HashSet

1.1基本用法

HashSet是一种哈希算法的集合

  • 数据结构： 哈希表，哈希散列表

  • 特点 ：操作速度快，根据哈希算法快速定位元素的存放位置

在这里插入图片描述

HashSet<String> set = new HashSet<String>();
set.add("aaa");
set.add("bbb");
set.add("ccc");
set.add("ddd");
set.add("aaa");// 相同元素不会添加到集合中
System.out.println(set);

/**
		 * set集合 
		 * add()  size()  remove  等都有，但是没有关于填入下标的方法
		 * set集合不能用下标访问，不能使用 普通的for循环进行遍历
		 */
for (String s : set) {
    System.out.println(s);
}

// addAll  添加一个集合  ---  可以用对list集合进行去重   list集合转为 了set集合
List<String> list = Arrays.asList(new String[]{"a","b","c","d","d","a"});
set.addAll(list);
System.out.println(set);

//使用构造方法将 list转为set集合
HashSet<String> set2 = new HashSet<String>(list);
System.out.println(set2);
1.2 HashSet如何判重

  • 添加元素时，调用该对象的hashcode()方法，获取一个哈希值

  • 根据哈希值，使用哈希算法确定一个哈希表中的位置

  • 如果该位置没有元素，则直接放入

  • 如果该位置有元素了，则调用两个对象的equals方法进行比较

    true: 则认为是同一个对象，无法添加，舍弃当前对象

    false:则认为不是同一个对象，以链式结构向当前位置进行追加，改变了哈希表的结构，会影响性能。

总结：

  • 判断重复的依据，两个对象hashCode值一致，并且equals也返回true ---- 同一个对象—集合中只能添加一个进去
  • 在set集合中防止相同对象被添加，需要 hashCode 和 equals都 重写
package javaSE13_Set集合;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;

public class Test01_HashSet {
	public static void main(String[] args) {
		Test01_HashSet t = new Test01_HashSet();
//		t.test1();
		t.test2();
	}
	
	/**
	 * 基本用法
	 */
	public void test1(){
		HashSet<String> set = new HashSet<String>();
		set.add("aaa");
		set.add("bbb");
		set.add("ccc");
		set.add("ddd");
		set.add("aaa");// 相同的元素不会添加到集合中
		System.out.println(set);
		/**
		 * add()  size()  remove 等方法都有，
		 * 但 与下标相关方法都没有
		 * set集合不能有下标访问，不能使用普通循环进行遍历
		 */
		for (String s : set) {
			System.out.println(s);
		}
		// addAll() 添加一个集合  -- 可用对list集合进行去重
		List<String> list =Arrays.asList(new String[]{"a","b","c","d","a","b"});
		set.addAll(list);
		System.out.println(set);
		
		//使用构造方法 将list转为set
		HashSet< String> set2 = new HashSet<String>(list);
		System.out.println(set2);
	  
	}
	
	/**
	 * HashSet 判断重复的标准
	 */
	public void test2(){
		HashSet<Student> set = new HashSet<Student>();
		Student s1 = new Student(1001, "tom");
		Student s2 = new Student(1001, "tom");
		System.out.println(s1.equals(s2));
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
		set.add(s1); set.add(s2);
		System.out.println(set);
		
		/**
		 * 如果认为学号  名字都一样，就是同一个学生，只需要添加一个到集合中
		 * 需要重写eq方法 和hashCode()
		 */
		
	}
}

2.TreeSet

2.1基本用法

用于对元素排序的有序集合

  • 数据结构:二叉树
  • 特点：元素有大小顺序
2.2排序

排序：

  1. 元素会根据自然顺序排列

    存入的元素不具有自然顺序 ，集合会报错 ----- 该对象不可比较

    解决： 让元素可以比较，将要比较的对象实现一个Comparable接口，表示该类型的对象可以比较

    ​ 并且重写compareTo（）方法，指定具体的比较规则

  2. 提供一个比较器，根据比较器进行排序

    定义一个比较器，就是定义一个实现了Compartor 接口的类，实现compare()方法

    在创建集合是，将比较器传入。

package javaSE13_Set集合;

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

public class Test02_TreeSet {
	public static void main(String[] args) {
		Test02_TreeSet t = new Test02_TreeSet();
//		t.test01();
		t.test02();
	}
	
	public void test01(){
		TreeSet<Integer> set = new TreeSet<Integer>();
		TreeSet<String> set2 = new TreeSet<String>();
		set.add(1);
		set.add(15);
		set.add(79);
		set.add(4);
		set.add(56);
		set.add(0);
		
		set2.add("abde");
		set2.add("fjek");
		set2.add("hueij");
		set2.add("aaeie");
		set2.add("djeju");
		System.out.println(set);
		System.out.println(set2);
	}
	public void test02(){
		//1.引用类型要能够比较大小，实现Comparable接口，并在compareTo方法中指定比较的规则
		TreeSet<User> set = new TreeSet<User>();
		set.add(new User(1, "aa", 12));
		set.add(new User(2, "bb", 15));
		set.add(new User(3, "cc", 2));
		set.add(new User(4, "dd", 15));
		set.add(new User(5, "ee", 34));
//		System.out.println(set);
		
		//2.通过比较器对set集合进行排序
//		A: 创建实现类
		/*MyComparator c = new MyComparator();//new一个比较器对象
		//set2集合的排序按照 c这个比较器对象中定义的规则排序
		TreeSet<User2> set2 = new TreeSet<User2>(c);*/
		
//		B: 直接创建的是接口，匿名内部类的写法，就不需要单独创建一个实现类
	/*	Comparator<User2> c = new Comparator<User2>(){
			//定义比较的规则
			@Override
			public int compare(User2 u1, User2 u2) {
				int i = u1.getAge() - u2.getAge();
				if(i==0){
					i=u1.getId() - u2.getId();
				}
				return i;
			}
		};
		TreeSet<User2> set2 = new TreeSet<User2>(c);*/
		
//		C: 再简化
		TreeSet<User2> set2 = new TreeSet<User2>(new Comparator<User2>() {
			@Override
			public int compare(User2 u1, User2 u2) {
				int i = u1.getAge() - u2.getAge();
				if(i==0){
					i=u1.getId() - u2.getId();
				}
				return i;
			}
		});
		set2.add(new User2(1, "aa", 12));
		set2.add(new User2(2, "bb", 15));
		set2.add(new User2(3, "cc", 2));
		set2.add(new User2(4, "dd", 15));
		set2.add(new User2(5, "ee", 34));
		System.out.println(set2);
	}
}


package javaSE13_Set集合;

import java.util.Comparator;
/**
 * 是一个比较器 ： 就是一个实现了Comparator接口的类
 * @author wenwen
 *
 */
public class MyComparator implements Comparator<User2>{
	//定义比较的规则
	@Override
	public int compare(User2 u1, User2 u2) {
		int i = u1.getAge() - u2.getAge();
		if(i==0){
			i=u1.getId() - u2.getId();
		}
		return i;
	}

}

注意：TreeSet判断重复的依据： 但添加的两个元素的compareTo（） 或者 是 compare（）方法 返回0时，就认为两个对象相同了，只会添加一个到集合中

package javaSE13_Set集合;

public class User implements Comparable<User>{
	private int id;
	private String name;
	private int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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 User() {
		super();
		// TODO Auto-generated constructor stub
	}
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]\n";
	}
	
	
	/**
	 *  自定义比较的规则
	 *  如果 按照 从小到大的顺序
	 *  负数： 小于
	 *  0： 等于
	 *  正数：this 为 大于
	 */
	/*@Override
	public int compareTo(User o) {
		//根据年龄进行比较     如果年龄相同 则继续按照另一个属性排序
		if(this.age>o.getAge()){// this.age-o.getAge  是个正数
			return 1;
		}else if(this.age < o.getAge()){
			return -1;
		}else{
			//年龄相同,id继续排
			if(this.id > o.getId()){
				return 1;
			}else if(this.id<o.getId()){
				return -1;
			}else{
				//如果 id继续相等，按照 姓名排
				// 如果 比较的是字符串，直接调用字符串的比较方法
				return this.name.compareTo(o.getName());
			}
		}
	}*/
	@Override
	public int compareTo(User o) {
		int i = this.age - o.getAge();
		if(i==0){
			i=this.id - o.getId();
			if(i==0){
				i=this.name.compareTo(o.getName());
			}
		}
		return i;
	}
}

package javaSE13_Set集合;

public class User2 {
	private int id;
	private String name;
	private int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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 User2() {
		super();
		// TODO Auto-generated constructor stub
	}
	public User2(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]\n";
	}
}
西瓜咬人啦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的Set集合
taraex的博客
05-15 231
set集合 特点： 存储是元素顺序和取出时元素顺序不一致；唯一，存入的元素唯一，不会出现重复 HashSet保证元素唯一性 HashSet 底层数据结构是哈希表. HashSet 不是线程安全的 集合元素可以是 null 哈希表:是一个元素为链表的数组,综合了数组和链表的优点 (像新华字典一样) (JDK1.7之前) 当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 ha...
Java集合-Set
喜欢前端的后端 MelodyJerry
01-01 465
2020.12.31 更新 待补充、完善ing…… Set概述 set集合不能存储相同的元素 同时因为其是一个抽象的接口：所以不能直接实例化一个set对象。 Set s = new Set() ：× 该接口主要继承于Collections接口，所以具有Collection的一些常见的方法。 常见用法 Sr.No. Method Description 1 add( ) 向集合中添加元素 2 clear( ) 去掉集合中所有的元素 3 contains( ) 判断集合中是否包含某
List add、addAll 和 set
yake1965
12-07 262
Java 中线性表 List 接口的插入方法有三大类，add、addAll 和 set。
Set集合中的addAll()方法
qq1922631820的博客
07-18 1万+
由于Set集合中不允许存在重复值，因此可以使用Set集合中的addAll()方法，将Collection集合添加到Set集合中并除掉重复值。 package test; import java.util.*; public class Main{ public static void main(String []args){ List<String> list = new ArrayList<String>(); list.add("a
Java Set 集合
最新发布
m0_51110997的博客
03-30 561
Set是 Java 集合框架中的一部分，它代表了一个不重复元素的集合。这意味着Set不允许包含重复的元素，每个元素在集合中都是唯一的。Set集合通常用于存储无序的、不重复的对象，例如一组唯一的整数或字符串。Set集合是 Java 中一种非常有用的数据结构，用于存储不重复的元素。本博客介绍了Set集合的基本概念、创建和初始化、基本操作、遍历、不同实现类、性能考虑、使用注意事项、高级用法以及示例代码。希望通过本文的介绍，您对Set集合有了更深入的了解，并能够在实际编程中灵活运用。
Java：关于List类中的add、addAll和set方法
热门推荐
<code> I am a coder </code>
04-06 13万+
    Java中有一个用于表示线性表的List接口，其中包含add、addAll和set三个用于向表中插入元素的方法，笔者近期在编码过程中，遇到了一些问题，并总结了一些注意事项，mark一下。·add方法：    List接口中的add方法有如下两种重载方式：        ① boolean add(E e);        ② void add(int index, E element);其...
HashSet装入ArrayList对象，去重
梦否
07-12 757
比如： HashSet<String> strings = new HashSet<>(list); // List<String> list; 对应的构造函数： // HashSet extends AbstractSet // AbstractSet extends AbstractCollection // HashMap<E,Object> map; public HashSet(Collection<? extends E> c) {
HashSet可以通过Arrays.asList这种方式添加元素！
天才小熊猫的客栈
04-05 771
privatefinalstaticHashSet<Character>vowels=newHashSet<>( Arrays.asList('a','e','i','o','u','A','E','I','O','U') );
java中Set集合保证元素一致性原理.md
09-11
HashSet集合保证元素一致性
Java中的Set集合简单汇总解析
08-25
主要介绍了Java中的Set集合简单汇总解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
浅析Java中的set集合类型及其接口的用法
09-02
Java本身对set集合提供了一个接口,一般的实现类是HastSet和 TreeSet,这里我们先来简要浅析Java中的set集合类型及其接口的用法:
Java实现Redis的集合(set)命令操作
08-18
主要介绍了Java实现Redis的集合(set)命令操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java-Java集合体系-List-Set
07-12
内容概要：总结了Java集体体系中的三大集合接口LIst、Set、Map，本文对LIst、Set做出了详细、简要的分析，没有冗长的文章，全是干货，下载即用，其中涉及了其底层实现，面试题必备。 学习收获：通过学习这篇文章，您...
JAVA通过HashSet方法对list实体对象去重
梦忆故城的博客
10-28 1103
1.原理 在实体对象类中重写hasCode方法和equals方法。先比较hasCode是否相等，若相等则不添加；若不等再比较equals方法，若也相等则添加元素，否则不添加。这种方法比循环遍历list元素更加高效。 hashSet的底层实际上就是一个hashMap的key值，因此不允许重复。 2.代码示例 2.1实体对象类 若实体对象元素中含有null，则使用equals比较时会报错，因此需要判别一下。 import java.util.Objects; public...
List集合，Set集合
weixin_54194900的博客
08-08 1360
remove里面的参数可以填下标也可以填元素，两者都有返回值，填元素的时候返回值是Boolean型，填下标的时候返回的就是删除的具体元素。经过查阅资料，发现如果不同时重写两个方法的话，会有隐藏的bug存在，这里推荐大家看一下下面这位大佬的博客，解释的很详细。当关于集合里面存储的是对象的时候，我们为了仍旧保持数据的唯一性，需要重写hascode和equals方法。注：日常开发使用最多的功能就是查询数据，遍历数据，所以该集合是最常用的集合。为set接口的一个实现类，存储元素不重复，且没有顺序。......
利用HashSet对list集合去重
Peter_Hao1015的博客
04-24 5608
分析以下需求，并用代码实现： (1)有如下代码： public static void main(String[] args) { List&lt;String&gt; list = new ArrayList&lt;&gt;(); list.add("a"); list.add("f"); list.add("b"); list.add("c"); list.add(&
java中的Set集合详解
m0_53222768的博客
08-29 1万+
原文之部分某处有争论，读者谨慎阅读，后期本人再进行本文内容修正 1.简介 Set集合中的元素是无序的且不可重复， 如果试图把两个相同元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入。 2.HasheSet底层数据结构 HashSet底层数据结构是哈希表，因此具有很好的存取和查找性能。 哈希表：一个元素为链表的数组，综合了链表（存储速度快）和数组（查询速度快）的优点。 3.哈希表的存取原理 3.1 调用对象的hashCode()方法，获得要存储元素的哈希值。
Java常用集合之Set
m0_62609939的博客
03-27 2520
Java常用集合之Set
集合：List接口：ArrayList,LinkedList Set接口：HashSet
qq_51810428的博客
08-11 157
集合 List接口 Set接口 实现类 ArrayList LinkedList HashSet 集合遍历 使用迭代器遍历集合 ArrayList常用方法 LinkedList常用方法
java中set集合用法
05-12
在Java中，Set是一种集合类型，它不允许重复元素，并且没有固定的顺序。常见的Set实现类有HashSet、LinkedHashSet和TreeSet。下面是Set的用法示例： 1. 创建Set对象 可以使用以下语法创建Set对象： ```java Set...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值