java中Set集合

最新推荐文章于 2024-08-21 23:20:00 发布
最新推荐文章于 2024-08-21 23:20:00 发布
阅读量626 收藏
点赞数
分类专栏： 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";
	}
}
西瓜咬人啦
关注
专栏目录
Java Set集合
qq_54556698的博客
09-15 986
HashSet集合的特点底层数据结构是哈希表对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致没有带索引的方法，所以不能使用普通for循环遍历由于是Set集合，所以是不包含重复元素的集合//创建集合对象 HashSet < String > hs = new HashSet < String >();//添加元素 hs . add("hello");//遍历 for(String s : hs) {} } }LinkedHashSet集合特点。
Java中Set系列集合
yhb500234的博客
08-31 570
本文主要概述了Set系列集合,主要包括HashSet,LinkedHashSet,TreeSet集合,不同的集合的性质有所不同,其中HashSet集合具有无序,不重复,无索引.LinkedHashSet具有,能排序,不重复,无索引.TreeSet是能排序,不重复,无索引...
Java中set集合
午-夜
07-11 1567
Set集合 set集合简单使用 package com.cloud.vector; import java.util.HashSet; import java.util.Set; public class Day2 { /*  --|Set 实现Set接口的集合类，无序，不可以重复         元素添加输出的顺序不一样 */    public
Java中的Set
最新发布
fengzeyuqwe的博客
08-21 352
Set是一个接口，与List集合类似，都需要通过实现类来对其进行操作。Set集合的特点如下。a.不包含重复的元素。b.没有带索引的方法，不能使用普通for循环遍历。
Java的Set集合
学源客的博客
07-03 633
Set集合
JAVA中Set集合
Yeauty的博客
11-23 752
HashSet存储字符串并遍历 A:Set集合概述及特点 通过API查看即可 B:案例演示HashSet存储字符串并遍历 HashSet<String> hs = new HashSet<>(); boolean b1 = hs.add("a"); boolean b2 = hs.add("a"); //当存储不成功的时候,返回falseSystem.out.println(b
Java中的Set集合
写条代码混日子
03-12 416
Set接口是Java中一个用来存放对象容器，是一个无序、不可重复的集合，存放于java.util包中 HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。我们大多数时候说的set集合指的都是HashSet HashSet 按照 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能 HashSet 具有以下特点： ①不能保证元素的排列顺序 ②不可重复...
java中Set集合保证元素一致性原理.md
09-11
HashSet集合保证元素一致性
Java中的Set集合简单汇总解析
08-25
Java中的Set集合简单汇总解析 Set接口简介： Set接口是Java集合框架中的一个重要接口，它继承自Collection接口，并没有对Collection接口进行功能上的扩充。Set接口的主要特点是元素无序，并且都会以某种规则保证...
浅析Java中的set集合类型及其接口的用法
09-02
Java中的Set集合是一种特殊的集合类型，它遵循了不存储重复元素的基本原则。Set接口是Collection接口的子接口，它的设计目标是确保集合中每个元素的唯一性。在Java中，Set接口有两个常用的实现类：HashSet和TreeSet...
java常用集合之Set
weixin_64938628的博客
06-30 4003
目录Set集合的基础知识Set集合的实现类一.HashSet二.TreeSet 特点：1.无序性：set集合是无序的2.不重复：set集合是不可以重复的遍历方法：foreach，迭代器扩容： 初始容量16，负载因子0.75，扩容增量1倍Set和List一样属于接口，无法直接创建实例化对象，需要实现类来set接口。关系图HashSet实现Set接口，底层由HashMap来实现，为哈希表结构，新增元素相当于HashMap的key，value默认为一个固定的Object。当有元素插入的时候，会计算元素的hashC
java之Set集合
achu19的博客
02-19 331
Set 1.Set接口继承于Collection 2.Set堆中存储的数据是无序的（不代表乱序：内部有序，外部无序） 3.存储的数据是不可重复的。当添加相同的元素时，只能添加一个元素 4.添加进Set中的元素一定要重写equals和hashCode方法 1)Set中的元素存储使用哈希算法 2)当向Set添加元素时，首先会调用该对象所造的类的哈希Code方法，计算对象的哈希值，决定了Set的位置。 ...
java中的Set集合
hangoer的博客
08-07 1153
Set集合 HashSet与TreeSet的区别 HashSet:底层是哈希表,线程不安全的 TreeSet:底层是⼆叉树,线程不安全的 哈希表 哈希表简介 Set集合的两个实现类HashSet与LinkedHashSet，底层实现都是哈希表。 Hash，⼀般翻译做“散列”，也有直接⾳译为“哈希”的，它是基于快速存取的⻆度设计的，也是⼀种典型的“空间换时间”的做法。顾名思义，该数据结构可以理解为⼀个线性表，但是其中的元素不是紧密排列的，⽽是可能存在空隙。 散列表（Hash table，也叫哈希表），是根据键
Java：set集合
weixin_42530700的博客
05-17 385
Set集合类似于一个罐子，程序可以依次把多个对象“丢进”Set集合，而Set集合通常不能记住元素的添加顺序。 　　Set集合不允许包含相同的元素，如果试图把两个相同的元素加入同一个Set集合中，则添加操作失败，add()方法返回 false，且新元素不会被加入。 一、HashSet类 　　HashSet类是Set接口的典型实现类，大多数时候使用Set集合时就是使用这个实现类。 HashSet类按H...
Java Set 集合
m0_51110997的博客
03-30 1378
Set是 Java 集合框架中的一部分，它代表了一个不重复元素的集合。这意味着Set不允许包含重复的元素，每个元素在集合中都是唯一的。Set集合通常用于存储无序的、不重复的对象，例如一组唯一的整数或字符串。Set集合是 Java 中一种非常有用的数据结构，用于存储不重复的元素。本博客介绍了Set集合的基本概念、创建和初始化、基本操作、遍历、不同实现类、性能考虑、使用注意事项、高级用法以及示例代码。希望通过本文的介绍，您对Set集合有了更深入的了解，并能够在实际编程中灵活运用。
java中set集合用法
05-12
在Java中，Set是一种集合类型，它不允许重复元素，并且没有固定的顺序。常见的Set实现类有HashSet、LinkedHashSet和TreeSet。下面是Set的用法示例： 1. 创建Set对象 可以使用以下语法创建Set对象： ```java Set<T> set = new HashSet<>(); // 创建HashSet对象 Set<T> set = new LinkedHashSet<>(); // 创建LinkedHashSet对象 Set<T> set = new TreeSet<>(); // 创建TreeSet对象 ``` 其中，T表示元素的类型。 2. 添加元素 可以使用add()方法向Set中添加元素： ```java set.add(element); // 将元素添加到Set中，如果Set中已经存在该元素，add()方法不会执行任何操作 ``` 3. 删除元素 可以使用remove()方法从Set中删除元素： ```java set.remove(element); // 从Set中删除指定元素，如果Set中不存在该元素，remove()方法不会执行任何操作 ``` 4. 判断元素是否存在 可以使用contains()方法判断Set中是否存在指定元素： ```java set.contains(element); // 如果Set中存在该元素，返回true；否则返回false ``` 5. 遍历元素 可以使用foreach循环或者迭代器遍历Set中的元素： ```java for (T element : set) { // 对元素进行操作 } Iterator<T> iterator = set.iterator(); while (iterator.hasNext()) { T element = iterator.next(); // 对元素进行操作 } ``` 6. 获取元素个数 可以使用size()方法获取Set中元素的个数： ```java set.size(); // 返回Set中元素的个数 ``` 7. 清空Set 可以使用clear()方法清空Set中的所有元素： ```java set.clear(); // 清空Set中的所有元素 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值