Java常用集合基础（Set、HashSet、TreeSet）

Set

1.概述和特点

继承Collection接口

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

package com.dong.set; import java.util.HashSet; import java.util.Set; public class SetDemo01 { public static void main(String[] args) { //        HashSet:对集合的迭代顺序不做任何保证 //创建集合对象 Set<String> set = new HashSet<>(); //添加元素,set集合不包含重复元素 set.add("hello"); set.add("world"); for (String s: set) { System.out.println(s); } } } 

2.哈希值

哈希值: 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值

对象的哈希值特点
●同一个对象多次调用hashCode( )方法返回的哈希值是相同的
默认情况下，不同对象的哈希值是不同的。而重写hashCode0方法，可以实现让不同对象的哈希值相同

package com.dong.set; import com.dong.arraylist.Student; public class HashDemo01 { public static void main(String[] args) { //创建学生对象 Student s1 = new Student(); //同一个对象多次调用hashCode()方法返回的哈希值是相同的 System.out.println(s1.hashCode());//460141958 System.out.println(s1.hashCode());//460141958 System.out.println("---------"); Student s2 = new Student(); //默认情况下，不同对象的哈希值是不相同的 //通过方法重写，可以实现不同对象的哈希值是相同的 System.out.println(s2.hashCode());//1163157884 System.out.println("hello".hashCode()); } } 

3.哈希表

JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
JDK8以后，在长度比较长的时候，底层实现了优化

通常判断数据存储在数组的那个位置用哈希值%16来判断

同一个位置存储时，先判断哈希值是否相同，若相同再判断值是否相同

HashSet

概念

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

HashSet集合添加一个元素的过程：

HashSet集合存储元素:
要保证元素唯一性，需要重写hashCode()和equals()

案例

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

需求:创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
要求:学生对象的成员变量值相同，我们就认为是同一个对象

思路:
①定义学生类
②创建HashSet集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合(增强for)

⑥在学生类中重写两个方法
hashCode()和equals()

package com.dong.list; import java.util.Objects; public class 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 boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Student student = (Student) o; return age == student.age && Objects.equals(name, student.name); } @Override public int hashCode() { return Objects.hash(name, age); } } 

package com.dong.set; import com.dong.list.Student; import java.util.HashSet; public class HashDemo01 { public static void main(String[] args) { //创建集合对象 HashSet<Student> hs = new HashSet<Student>(); Student s1 = new Student("张三",20); Student s2 = new Student("李四",21); Student s3 = new Student("王五",22); Student s4 = new Student("王五",22); //添加学生到集合 hs.add(s1); hs.add(s2); hs.add(s3); hs.add(s4); //遍历 for (Student s : hs) { System.out.println(s.getName()+"  "+s.getAge()); } } } 

LinkedHashSet

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

package com.dong.set; import java.util.LinkedHashSet; public class LinkedHashSetDemo { public static void main(String[] args) { //创建集合对象 LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>(); //添加集合对象 linkedHashSet.add("hello"); linkedHashSet.add("world"); //遍历集合 for (String s:linkedHashSet ) { System.out.println(s); } } } 

TreeSet

概述

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

package com.dong.set; import java.util.TreeSet; public class TreeSetDemo01 { public static void main(String[] args) { //创建集合对象 TreeSet<Integer> treeSet = new TreeSet<Integer>(); //添加集合 treeSet.add(10); treeSet.add(50); treeSet.add(20); treeSet.add(40); treeSet.add(60); //遍历集合 for (Integer i: treeSet) { System.out.println(i); } } } 

自然排序Comparable的使用

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

package com.dong.set; 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; //年龄相同判断内容是否相同 int num2 = num == 0 ? this.name.compareTo(s.name) : num; return num2; } } 

package com.dong.set; import com.dong.set.Student; import java.util.TreeSet; //存储学生对象并遍历，创建TreeSet集合使用无参构造方法 //要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序 public class TreeSetDemo02 { public static void main(String[] args) { //创建集合对象 TreeSet<Student> treeSet = new TreeSet<>(); //创建学生对象 Student s1=new Student("张三",20); Student s2=new Student("李四",31); Student s3=new Student("王五",30); Student s4=new Student("小六",24); //添加学生对象到集合 treeSet.add(s1); treeSet.add(s2); treeSet.add(s3); treeSet.add(s4); //遍历集合 for (Student s: treeSet) { System.out.println(s.getName()+" "+s.getAge()); } } } 

比较器排序Comparator的使用

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

package com.dong.set; import com.dong.arraylist.Student; import java.util.Comparator; import java.util.TreeSet; public class TreeSetDemo03 { public static void main(String[] args) { //创建集合对象 TreeSet<Student> treeSet= new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { int num = s1.getAge() - s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); Student s1=new Student("张三",20); Student s2=new Student("李四",31); Student s3=new Student("王五",30); Student s4= new Student("小六",24); //添加学生对象到集合 treeSet.add(s1); treeSet.add(s2); treeSet.add(s3); treeSet.add(s4); //遍历集合 for ( Student s: treeSet) { System.out.println(s.getName()+" "+s.getAge()); } } } 

案例一

package com.dong.set; import java.util.Comparator; import java.util.TreeSet; public class TreeSetDemo04 { public static void main(String[] args) { TreeSet<Student1> student1s = new TreeSet<>(new Comparator<Student1>() { @Override public int compare(Student1 s1, Student1 s2) { //主要条件 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; } }); //创建学生对象 Student1 s1 = new Student1("张三", 80, 84); Student1 s2 = new Student1("李四", 89, 89); Student1 s3 = new Student1("王五", 90, 86); Student1 s4 = new Student1("小刘", 89, 87); Student1 s5 = new Student1("小王", 89, 87); //将学生对象放入集合 student1s.add(s1); student1s.add(s2); student1s.add(s3); student1s.add(s4); student1s.add(s5); //遍历集合 for (Student1 s : student1s) { System.out.println("姓名:" + s.getName() + " 数学:" + s.getMath() + " 语文:" + s.getChinese() + " 总分:" + s.getSum()); } } } 

案例二

不重复的随机数

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

思路:
①创建Set集合对象
②创建随机数对象
③判断集合的长度是不是小于10
是:产生一个随机数，添加到集合
回到3继续
④遍历集合

package com.dong.set; import java.util.HashSet; import java.util.Random; import java.util.Set; import java.util.TreeSet; public class TreeSetDemo05 { public static void main(String[] args) { //创建Set集合对象 //Set<Integer> set = new HashSet<Integer>(); Set<Integer> set = new TreeSet<Integer>(); //创建随机数对象 Random random = new Random(); //判断集合的长度是不是小于10 while(set.size()<10){ int number=random.nextInt(20)+1; set.add(number); } //遍历集合 for (Integer i:set ) { System.out.println(i); } } } 

本文地址：https://blog.csdn.net/dongtianyu_/article/details/107881830