Set集合的学习

最新推荐文章于 2022-11-19 09:46:25 发布
最新推荐文章于 2022-11-19 09:46:25 发布
阅读量160 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luzhu1234/article/details/80257446
版权
Set集合和List集合的区别?
   Set集合:不允许元素重复,唯一的(元素可以为null) ,不能保证迭代的顺序恒久不变(底层哈希表和hascode)
    无序(存储和取出不一致)

  List:允许元素重复,并且存储特点:有序性(存储和取出一致)

我们可通过一段代码来了解Set集合的这个特点

public static void main(String[] args) {
		
		//创建Set集合对象,子实现类:HashSet集合
		Set<String> set = new HashSet<String>();
		
		//添加元素
		set.add("hello") ;
		set.add("java") ;
		set.add("world") ;
		//看他的唯一性,多存储一些元素
		set.add("hello") ;
		set.add("java") ;
		set.add("world") ;
		//遍历
		for(String s: set) {
			System.out.println(s);
		}
	}
}//java
//world
//hello

我们可以看到，输出结果既没有重复的，顺序也不是我们录入的顺序。

对此，我们又有了一个新发现，即Set集合存储元素的时候,可以保证元素的唯一性,原因什么?

对此我们可以通过看它的源码学习:
    HashSet集合的add方法底层依赖于双列集合HashMap,它依赖于两个方法,HashCode()方法和equals()方法
  先比较字符串的HashCode()码值是否一样,再比较equals()方法
      如果hasCode码值一样,还要比较内容是否相同,由于存储String类型,所以重写了equals()方法

 String本身重写了equals方法,所以不需要再重写了。

 set集合存储自定义对象并遍历

public class Student {
	
	private String name  ;
	private int age ;
	
	public Student() {
		super();
	}

	
	public Student(String name, int age) {
		super();
		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 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) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) 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;
	}	
}


public static void main(String[] args) {
			Set<Student> set = new HashSet<Student>() ;
			
			//创建学生对象
			Student s1 = new Student("高圆圆", 27) ;
			Student s2 = new Student("高圆圆", 28) ;
			Student s3 = new Student("文章", 30) ;
			Student s4 = new Student("马伊琍", 39) ;
			Student s5 = new Student("高圆圆", 27) ;
			
			//存储到集合中
			set.add(s1) ;
			set.add(s2) ;
			set.add(s3) ;
			set.add(s4) ;
			set.add(s5) ;
			
			//遍历
			for(Student s : set) {
				System.out.println(s.getName()+"---"+s.getAge());
			}
		}
}

如果在开发中,元素唯一性,并且还要保证元素有序(存储和取出一致),使用LinkedHashSet集合

 如果开发中要使用集合排序的问题,使用TreeSet集合(红黑树结构)。
  自然排序
选择器排序
 
LinkedHashSet集合:
  底层是一种链接列表和哈希表组成
可以保证元素的唯一性,是由哈希表决定的(hashCode()和equals())

  可以保证元素的迭代顺序一致(有序),存储和取出一致,是由链表决定。

public static void main(String[] args) {
		
		//创建LinkedHashSet集合对象
		LinkedHashSet<String> link = new LinkedHashSet<String>() ;
		
		//添加元素
		link.add("hello") ;
		link.add("java") ;
		link.add("world") ;
		link.add("world") ;
		link.add("world") ;
		link.add("java") ;
		//增强for遍历
		for(String s: link) {
			System.out.println(s);
		}
	}//hello
        //java
        //world
TreeSet集合模拟情况下是通过自然顺序对集合中的元素排序

TreeSet:
   可以保证元素唯一并且元素排序(Integer类型的元素自然升序)
  自然排序
比较器排序
 
 

 给TreeSet集合存储以下元素:20,23,22,18,17,19,24,21..

我们可以看下面的代码

public static void main(String[] args) {
		//创建一个集合对象TreeSet集合对象
		TreeSet<Integer> ts = new TreeSet<Integer>() ;
		
		//给集合中存储元素
		ts.add(20) ;		//add()方法底层的源码是一个Map接口实例
		ts.add(22) ;
		ts.add(18) ;
		ts.add(23) ;
		ts.add(24) ;
		ts.add(17) ;
		ts.add(19) ;
		ts.add(18) ;
		ts.add(21) ;
		
		//遍历
		for(Integer i : ts) {
			System.out.print(i +" ");
		}
	}

TreeSet集合的构造方式不同,使用的排序也不同
  自然排序:自定义的类实现Compareable接口,然后创建TreeSet对象,通过无参构造形式创建对象
  比较器排序 :public TreeSet(Comparator<E> comparator)
 
两种方式:
  1)自定义一个类,该类实现Comparator接口,重写Comparator接口中的compare()方法
2)直接使用接口匿名内部类的方式实现

TreeSet集合保证元素唯一,是看返回值是否为0 
保证元素进行排序,两种排序方式


我们先看自然排序。

做这样一个练习：

需求:使用TreeSet集合存储自定义对象(Student类型),并遍历!

按照学生的年龄从小到大进行排序 (主要条件)
  
唯一性:

若成员变量的值一样则认为是同一个对象

//对于自定义的类型,要实现自然排序,必须自定义的类型必须实现Comparable
//实现接口中的方法,compareTo() :比较方法
public class Student  implements Comparable<Student>{
	
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}
	
	public Student(String name, int age) {
		super();
		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) {	//源码 cmp = k.compareTo(t.key)
		//return 0;
		//按照某种规则,前提必须有这规则
		//主要条件:按照年龄从小到大
		int num  = this.age - s.age ; //如果年龄相等,不一定是同一个人
		//需要自己分析次要条件;
		//年龄相同,姓名的内容不一定相同,比较姓名
		int num2 = num==0 ? this.name.compareTo(s.getName()) : num ;
		return num2 ;
	}
}
public static void main(String[] args) {
		//创建TreeSet集合对象
		TreeSet<Student> ts  = new TreeSet<Student>() ;//无参构造的方式自然排序
		
		//创建学生对象
		Student s1 = new Student("gaoyuanyuan",27) ;	
		Student s2 = new Student("liushishi",38) ;
		Student s3 = new Student("gaoyuanyuan",28) ;
		Student s4 = new Student("wanglihong",35) ;
		Student s5 = new Student("wanglihong",30) ;
		Student s6 = new Student("fengqingy",38) ;
		Student s7 = new Student("gaoyuanyuan",27) ;
		//java.lang.ClassCastException: org.westos_03.Student cannot be cast to java.lang.Comparable
		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());
		}
	}//gaoyuanyuan---27
         //gaoyuanyuan---28
        //wanglihong---30
        //wanglihong---35
        //fengqingy---38
        //liushishi---38

我们可以看到是按照年龄从小到大排列的，也可以按照姓名的长度进行排列，我们看一下代码。

public class Student implements Comparable<Student> {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		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;
	}
	
	//TreeSet集合保证元素的唯一性,看返回值是否为0
	@Override
	public int compareTo(Student s) {
		
		//按照姓名的长度进行比较(默认从小到大)
		int num = this.getName().length() - s.getName().length() ;
		
		//如果姓名的长度一样,还要比较他们的内容是否相同
		int num2 = num == 0 ?	this.getName().compareTo(s.getName()) :num ;
		
		//如果姓名长度和姓名的内容都一致,也不能保证就是同一个人,还要比较年龄
		int num3 = num2== 0 ? this.age-s.age :num2 ;
		return num3 ;
	}	
}

/*TreeSet集合存储自定义对象(Student)
* 
* 	按照姓名的长度从小到大进行比较 :主要条件*/
public class TreeSetDemo {
	public static void main(String[] args) {
		
		//创建TreeSet集合,实现对该类型自然排序
		TreeSet<Student> ts = new TreeSet<Student> ();
		
		//创建学生对象
		Student s1 = new Student("gaoyuanyuan", 27) ;
		Student s2 = new Student("zhangguorong",29) ;
		Student s3 = new Student("wuqilong", 40) ;
		Student s4 = new Student("liushishi", 28) ; 
		Student s5 = new Student("fengqingy", 29) ;
		Student s6 = new Student("gaoyuanyuan", 22) ;
		Student s7 = new Student("gaoyuanyuan", 27) ;
		
		//添加元素
		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());
		}
	}
}    //wuqilong---40
    //fengqingy---29
    //liushishi---28
    //gaoyuanyuan---22
    //gaoyuanyuan---27
    //zhangguorong---29

我们可以看到，是按照姓名的长度排列的，当长度一样的时候，是按照年龄大小排的。

我们再来看比较器排序，它有两种方式。

  两种方式:
  1)自定义一个类,该类实现Comparator接口,重写Comparator接口中的compare()方法
2)直接使用接口匿名内部类的方式实现

（1）

public class Student {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		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;
	}
}

//自定义类,该类实现Comparator保证集合中的元素进行比较器排序
public class MyComparator implements Comparator<Student> {

	@Override
	public int compare(Student s1, Student s2) {
		
		/**
		 * 自然排序:Comparable 里面compareTo(Student s)
		 *this---->s1
		 *s---s
		 */
		//return 0;
		//按照姓名长度进行比较
		int num = s1.getName().length() - s2.getName().length() ;
		//长度一样,还要比较姓名的内容是否相同
		int num2 = num==0 ?s1.getName().compareTo(s2.getName()) : num ;
		
		//最终看年龄是否一致
		int num3 = num2 ==0 ? (s1.getAge() - s2.getAge()) : num2 ;
		return num3 ;
	}
}


public static void main(String[] args) {
		
		//创建TreeSet集合对象
                //TreeSet<Student> ts = new TreeSet<Student>() ;	  //无参构造形式,自然排序
		//选择器排序
		//Comparator是一个接口
                TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()) ;
                //创建学生对象
		Student s1 = new Student("gaoyuanyuan", 27) ;
		Student s2 = new Student("zhangguorong",29) ;
		Student s3 = new Student("wuqilong", 40) ;
		Student s4 = new Student("liushishi", 28) ; 
		Student s5 = new Student("fengqingy", 29) ;
		Student s6 = new Student("gaoyuanyuan", 22) ;
		Student s7 = new Student("gaoyuanyuan", 27) ;
		
		
		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());
		}
	}
}//wuqilong----40
//fengqingy----29
//liushishi----28
//gaoyuanyuan----22
//gaoyuanyuan----27
//zhangguorong----29

(2)

public class Student {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}
	public Student(String name, int age) {
		super();
		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;
	}
}

public static void main(String[] args) {
		
		//创建TreeSet集合对象
//		TreeSet<Student> ts = new TreeSet<Student>() ;	  //无参构造形式,自然排序
		//选择器排序
		//Comparator是一个接口
//		TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()) ;
		
		//直接使用匿名内部类的方式实现
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {

			@Override
			public int compare(Student s1, Student s2) {
				
				/**
				 * 自然排序:Comparable 里面compareTo(Student s)
				 * 
				 *this---->s1
				 *s---s
				 */
				//return 0;
				//按照姓名长度进行比较
				int num = s1.getName().length() - s2.getName().length() ;
				//长度一样,还要比较姓名的内容是否相同
				int num2 = num==0 ?s1.getName().compareTo(s2.getName()) : num ;
				
				//最终看年龄是否一致
				int num3 = num2 ==0 ? (s1.getAge() - s2.getAge()) : num2 ;
				return num3 ;
			}
			
			
		}) ;
		
		//创建学生对象
		Student s1 = new Student("gaoyuanyuan", 27) ;
		Student s2 = new Student("zhangguorong",29) ;
		Student s3 = new Student("wuqilong", 40) ;
		Student s4 = new Student("liushishi", 28) ; 
		Student s5 = new Student("fengqingy", 29) ;
		Student s6 = new Student("gaoyuanyuan", 22) ;
		Student s7 = new Student("gaoyuanyuan", 27) ;
		
		
		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());
		}
	}
}
//wuqilong----40
//fengqingy----29
//liushishi----28
//gaoyuanyuan----22
//gaoyuanyuan----27
//zhangguorong----29





珠小猪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
集合-list
9.冄2.7.號的博客
08-29 267
Collection集合的概述 Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。 一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。 JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。 此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。 Collection集合的基本功能测
Java中集合的遍历Iterator(迭代器)的两个小练习(存储字符串并遍历，存储自定义对象并遍历Student(name,age))!
不会下雨的云的博客
05-10 842
练习1：存储字符串并遍历 话不多说，直接上代码： import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /* * 需求：存储字符串并遍历 * * 分析： * A：创建集合对象 * B：创建字符串对象 * C：把字符串对象添加到集合中 * D：遍历集合 * *...
HashSet集合存储自定义对象并遍历
zgq258的博客
02-15 699
HashSet集合存储自定义对象并遍历。 如果对象的成员变量值相同即为同一个对象。 分析： 1、创建一个学生类 2、创建HashSet集合对象 3、创建5个学生对象 4、将学生对象添加到集合中 5、遍历 import java.util.Objects; public class Student1 { private String name; private int age; public Student1() { } public Student..
对象遍历php,PHP对象的遍历
weixin_39649611的博客
04-11 94
Java基础知识强化之集合框架笔记46：Set集合之TreeSet存储自定义对象并遍历练习2(自然排序：Comparable)1.TreeSet存储自定义对象并遍历练习2: (1)Student.java package cn.itcast_06; /* * 如果一个类的元素要想能够进行自然排序,就必须实现自然排序接口 * ...Java基础知识强化之集合框架笔记45：Set集合之TreeSet...
Java 集合框架（中）——List集合
hewenqing
01-09 318
目录 Collection案例（巩固知识） 一、List接口 List案例： List集合的特有功能： ListIterator接口的成员方法 List集合的三个常用的子接口： 1、ArrayList类概述及使用 2、Vector类概述及使用 3、LinkedList类概述及使用 List集合练习 Collection案例（巩固知识） 存储字符串并遍历 存储...
快速学习-Python Set集合
12-21
11. Set集合 集合不支持切片操作。 11.1 Set集合创建 s = {'name','aa','bb'} s = set(序列) # dict序列，值添加key s = {x for x in range(10) if x not in range(5,10)} 11.2 Set集合添加元素 s.add(x) # 添加...
Java学习|集合（三）——set
01-06
文章目录Set常用方法介绍HashSet元素顺序底层算法TreeSet![在这里插入图片描述](https://img-blog.csdnimg.cn/20200217154420892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0...
Java中的Set集合简单汇总解析
08-25
主要介绍了Java中的Set集合简单汇总解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python中集合类型（set）学习小结
09-22
主要介绍了Python中集合类型（set）学习小结,本文讲解了set的初始化、运算操作、基本方法等内容,需要的朋友可以参考下
python set集合使用方法解析
09-18
主要介绍了python set集合使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
存储自定义对象并遍历Student(name,age)
why
08-04 1448
package cn.itcast_04; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /*  * 需求：存储自定义对象并遍历Student(name,age)  *  * 分析：  * A:创建学生类  * B:创建集合对象  * C:创
HashSet集合存储学生对象并遍历
o676448的博客
03-05 851
需求:创建一个存储学生对象的集合,存储多个学生对象,使用程序控制台遍历该集合 要求:学生对象的成员变量值相同,我们就认为是同一个对象 思路: 定义学生类 创建学生对象 把学生添加集合里 在学生类中重写两个方法:HashSet要确保元素的唯一性，需要重写hashCode()和equal()方法 遍历集合(Iterator方法或者foreach)
Java基础知识强化之集合框架笔记40：Set集合之HashSet存储自定义对象并遍历
weixin_30888707的博客
10-06 86
1. HashSet存储自定义对象并遍历 2. 代码示例： （1）Student类，如下： 1 package cn.itcast_02; 2 3 /** 4 * @author Administrator 5 * 6 */ 7 public class Student { 8 private String name; 9 pr...
java set集合
qq_46210699的博客
07-23 79
Set集合类似于一个罐子，程序可以依次把多个对象“丢进”Set集合，而Set集合通常不能记住元素的添加顺序。实际上Set就是Collection只是行为略有不同(Set不允许包含重复元素)。 Set集合不允许包含相同的元素，如果试图把两个相同元素加入同一个Set集合中，则添加操作失败，add()方法返回false，且新元素不会被加入。 Set<Student> set=new HashSet<>(); Student s1=new Student("ll",1
JAVA基础 之 Set
snkcxy的博客
02-22 85
概述：     1.Set不允许重复数据，判断重复标准：equals方法     2.HashSet         1.无序（序号的序），允许存在null        2.hashCode值决定它在HashSet中的位置，通过hashCode值算出存储位置        3.判断重复标准：equals方法 和 hashCode方法 同时相等              a.如果e...
Set集合
m0_65014697的博客
11-19 395
java set集合
java软件工程师工作业绩_java软件工程师的工作描述怎么写
weixin_42522953的博客
12-23 5043
展开全部1、负责研发62616964757a686964616fe4b893e5b19e31333365656636公司应用软件的模块设计、开发和交付2、负责编码，单元测试3、按照功能组件的详细设计4、对其他软件工程师的代码进行审核5、参与新知识的学习和培训6、修复程序BUG7、参与与其业务相关的需求变更评审8、完成上级交办的其他事宜9、编写技术设计文档Java是一门面向对象编程语言，不仅吸收了C...
Set集合基础学习笔记
baidu_41924510的博客
04-16 227
1、增强型for循环语法：for（数据类型  变量：集合/数组）｛  ｝缺点：会存在并发问题import java.util.ArrayList; import java.util.Collection; public class ForDemo { public static void main(String[] args) { Collection&lt;String&gt; sc =...
java集合允许null值_java各常用集合类是否接受null值
weixin_36255718的博客
02-27 1710
特例说明：TreeMap、TreeSet两个类在加入第二个元素时，会调用Comparator比较器比较先后加入的元素是否重复(TreeMap比较的是Key值)。所以当加入第一个元素时，即使第一个元素是null，也不会报错，因为此时不会调用比较器，再次加入元素则报错。已测试的其他集合类HashSet / HashMap / ArrayList / LinkedList均可接受null值。packag...
python中set集合
最新发布
11-07
Python中的集合（set）是一种无序且不重复的数据类型，它的元素都是唯一的，互不相同。可以使用大括号{}或者set()函数来创建一个集合。集合支持多种数学运算，例如并集、交集、差集等。可以使用add()方法向集合中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值