Set集合
定义:
一个不包含重复元素的 collection。更确切地讲,set 不包含满足 e1.equals(e2)
的元素对 e1
和
e2
,并且最多包含一个 null 元素。正如其名称所暗示的,此接口模仿了数学上的 set 抽象
Set集合特点:元素唯一,不包含也不重复但是是无序集合
Set3个子类集合
HashSet底层数据结构是哈希表(JDK1.7 数组+链表 JDK1.8 优化 数组+链表+红黑树)
LinkedHashSet
TreeSet
01_HashSet
特点:元素唯一
HashSet概述
当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值,
然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
HashSet 集合判断两个元素相等的标准:
两个对象通过 hashCode() 方法比较相等,并且两个对象的 equals() 方法返回值也相等。
结论:HashSet 保证元素唯一性是靠元素重写hashCode()和equals()方法来保证的,如果不重写则无法保证。
@Override
public int hashCode() {
// return 0;
// 因为成员变量值影响了哈希值,所以我们把成员变量值相加即可
// return this.name.hashCode() + this.age;
// 看下面
//s1:name.hashCode()=40,age=30
//s2:name.hashCode()=20,age=50
//尽可能的区分,我们可以把它们随变乘以一些整数
return this.name.hashCode() + this.age * 15;
}
HashSet集合保证元素的唯一性,是靠元素重新hashCode和equals()方法来保证的,如果元素不重写,则无法保证元素的 唯一性。
案例演示
package SetDemo01;
import java.util.HashSet;
public class SetTest01 {
public static void main(String[] args) {
//Set集合特点:元素唯一,不包含也不重复
HashSet<String> string = new HashSet<>();
string.add("詹姆斯");
string.add("韦德");
string.add("安东尼");
string.add("保罗");
string.add("詹姆斯");
string.add("韦德");
string.add("安东尼");
//遍历
for (String str:string) {
System.out.print(str+"\t");//保罗 詹姆斯 韦德 安东尼
}
HashSet<Integer> set2 = new HashSet<>();
set2.add(200);
set2.add(200);
set2.add(200);
set2.add(200);
set2.add(200);
set2.add(100);
set2.add(300);
System.out.println(set2);// [100, 200, 300]
}
}
HashSet 底层用的HashMap 这个集合来存的
合理的重写hashCode方法,为了减少equals()方法的调用次数,也就是说为了减少碰撞。
案例演示1:student
package SetDemo01;
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);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类
package SetDemo01;
import java.util.HashSet;
public class SetTest02 {
public static void main(String[] args) {
//HashSet 底层用的HashMap 这个集合来存的
//合理的重写hashCode方法,为了减少equals()方法的调用次数,也就是说为了减少碰撞。
HashSet<Student> hashSet = new HashSet<>();
hashSet.add(new Student("詹姆斯", 35));
hashSet.add(new Student("韦德", 34));
hashSet.add(new Student("安东尼", 32));
hashSet.add(new Student("韦德", 34));
hashSet.add(new Student("安东尼", 32));
hashSet.add(new Student("保罗", 30));
//遍历集合
for (Student list : hashSet) {
System.out.println(list);
}
}
}
02_LinkedHashSet
数据结构 有两个 链表和哈希表
链表保证有序 哈希表保证元素唯一
LinkedHashSet 元素有序,且唯一,底层数据结构是链表+哈希表 链表保证元素有序,哈希表保证元素唯一
package LinkedHashSetDemo01;
import java.util.LinkedHashSet;
public class LinkedHashSetTest01 {
public static void main(String[] args) {
//LinkedHashSet 元素有序,且唯一,底层数据结构是链表+哈希表 链表保证元素有序,哈希表保证元素唯一
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(100);
linkedHashSet.add(100);
linkedHashSet.add(100);
linkedHashSet.add(200);
linkedHashSet.add(300);
linkedHashSet.add(400);
for (Integer integer : linkedHashSet) {
System.out.println(integer);
}
}
}
03_TreeSet
TreeSet集合的特点: 元素唯一,并且可以对元素进行排序
排序:
a: 自然排序
b: 使用比较器排序
到底使用的是哪一种的排序取决于,构造方法.
注意:使用TreeSet集合进行元素的自然排序,那么对元素有要求,要求这个元素
必须实现Comparable接口 否则无法进行自然排序
03.1_TreeSet保证元素唯一和自然排序的原理和图解
TreeSet保证元素唯一和自然排序的原理和图解
二叉树的数据结构 先存入一个树根 分两个叉
存储元素时 跟树根比较 小的放在左边 大的放在右边
如果相等就不存储
取的时候按照 左中右的顺序来取
案例演示:创建TreeSet
package TreeSetDemo01;
import java.util.TreeSet;
public class TreeSetTest01 {
public static void main(String[] args) {
//TreeSet 底层数据结构是二叉树,元素唯一,且能对元素进行排序。
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(20);
treeSet.add(18);
treeSet.add(23);
treeSet.add(22);
treeSet.add(17);
treeSet.add(24);
for (Integer integer : treeSet) {
System.out.print(integer+"\t");//17 18 20 22 23 24
}
}
}
案例演示:实现了Comparable重写了 compareTo(自然排序)
package TreeSetDemo01;
import java.util.Objects;
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 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);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student s) {
/* //按照年龄大小来排序
int num=this.age-s.age;//两个年龄相减,如果为0,就比较姓名
int num1=num==0?this.name.compareTo(s.name):num;
return num1;
*/
//按照姓名长度排序
int num=this.name.length()-s.name.length();
//比较姓名内容
int num1= (num == 0) ? this.name.compareTo(s.name):num;
//比较年龄
int num2=num1==0?this.age-s.age:num1;
return num2;
}
}
测试类
package TreeSetDemo01;
import java.util.TreeSet;
//TreeSet的两种排序
//自然排序:采用空参构造, 自然排序对元素有要求,要求元素必须实现一个Comparable 接口 重写 compareTo(T o);
//根据compareTo(T o);的返回值的 正 负 0 来决定元素在二叉树中放置左右的位置
public class TreeSetTest02 {
public static void main(String[] args) {
TreeSet<Student> treeSet = new TreeSet<>();
treeSet.add(new Student("勒布朗詹姆斯aa", 35));
treeSet.add(new Student("布朗尼詹姆斯aaaaa", 15));
treeSet.add(new Student("詹姆斯哈登a", 30));
treeSet.add(new Student("詹姆斯哈登a", 30));
treeSet.add(new Student("安东尼戴维斯aaaaaaa", 26));
treeSet.add(new Student("安东尼戴维斯sfsdg", 26));
treeSet.add(new Student("贾维尔戴维斯vdfgd", 26));
treeSet.add(new Student("贾维尔戴维斯asffw", 22));
//按照学生的年龄大小来排序
for (Student student : treeSet) {
System.out.println(student.getName()+"=="+student.getAge());
}
//按照姓名长度来排序
}
}
注意:自然排序 此对象 必须实现Comparable接口 否则报错
案例演示:比较器排序
package TreeSetDemo01;
import java.util.Objects;
public class Student1 {
private String name;
private int age;
public Student1() {
}
public Student1(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;
Student1 student1 = (Student1) o;
return age == student1.age &&
Objects.equals(name, student1.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类
package TreeSetDemo01;
import java.util.Comparator;
import java.util.TreeSet;
public class ComparatorTest02 {
public static void main(String[] args) {
//TreeSet 排序方式2:比较器排序 ,使用有参构造。
/* TreeSet(Comparator < ? super E > comparator)
构造一个新的空 TreeSet,它根据指定比较器进行排序。
Comparator 比较器
*/
//比较器排序
TreeSet<Student1> treeSet = new TreeSet<>(new myComparator());
treeSet.add(new Student1("勒布朗詹姆斯aa", 35));
treeSet.add(new Student1("布朗尼詹姆斯aaaaa", 15));
treeSet.add(new Student1("詹姆斯哈登a", 30));
treeSet.add(new Student1("詹姆斯哈登a", 30));
treeSet.add(new Student1("安东尼戴维斯aaaaaaa", 26));
treeSet.add(new Student1("安东尼戴维斯sfsdg", 26));
treeSet.add(new Student1("贾维尔戴维斯vdfgd", 26));
treeSet.add(new Student1("贾维尔戴维斯asffw", 22));
for (Student1 student1:treeSet) {
System.out.println(student1);
}
}
}
class myComparator implements Comparator<Student1>{
@Override
public int compare(Student1 s1, Student1 s2) {
//按年龄大小来排序
int num=s1.getAge()-s2.getAge();
int num1=num==0?s1.getName().compareTo(s2.getName()):num;
return num1;
}
}
案例演示1:使用匿名内部类进行传参
package TreeSetDemo01;
import java.util.Comparator;
import java.util.TreeSet;
//比较器排序
public class ComparatorTest01 {
public static void main(String[] args) {
/*使用匿名内部类来传参*/
TreeSet<Student1> treeSet = new TreeSet<Student1>(new Comparator<Student1>() {
@Override
public int compare(Student1 s1, Student1 s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
treeSet.add(new Student1("勒布朗詹姆斯aa", 35));
treeSet.add(new Student1("布朗尼詹姆斯aaaaa", 15));
treeSet.add(new Student1("詹姆斯哈登a", 30));
treeSet.add(new Student1("詹姆斯哈登a", 30));
treeSet.add(new Student1("安东尼戴维斯aaaaaaa", 26));
treeSet.add(new Student1("安东尼戴维斯sfsdg", 26));
treeSet.add(new Student1("贾维尔戴维斯vdfgd", 26));
treeSet.add(new Student1("贾维尔戴维斯asffw", 22));
for (Student1 student1 : treeSet) {
System.out.println(student1);
}
}
}
案例演示2:
package TreeSetDemo01;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
public class ComparatorTest03 {
//数组使用比较器排序
//匿名内部类来传参
public static void main(String[] args) {
Integer[] arr = {99, 23, 32, 45, 10, 20, 30, 40};
//sort排序方法
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer a, Integer b) {
return a - b;
}
});
System.out.println(Arrays.toString(arr));//[10, 20, 23, 30, 32, 40, 45, 99]
//集合用法
ArrayList<Integer> list = new ArrayList<>();
list.add(2);
list.add(23);
list.add(22);
list.add(29);
list.add(1);
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
System.out.println(list);//[1, 2, 22, 23, 29]
}
}