1.1 EnumSet
EnumSet：是枚举的专用Set。所有的元素都是枚举类型
1.1 HashSet
常用方法：
-
boolean add(E e) 将指定的元素添加到此集合（如果尚未存在）。
-
void clear() 从此集合中删除所有元素。
-
boolean contains(Object o) 如果此集合包含指定的元素，则返回 true 。
-
boolean remove(Object o) 如果存在，则从该集合中删除指定的元素。
-
int size() 返回此集合中的元素个数。
HashSet特点：
-
HashSet：无序不重复，无索引
-
默认不重复的是虚地址，要想内容不重复，就重写hashcode和equals方法。
-
底层是HashMap实现，HashMap底层是由数组+链表+红黑树实现
-
HashSet堪称查询速度最快的集合，因为其内部是以HashCode来实现的。它内部元素的顺序是由哈希码来决定的，所以它不保证set的迭代顺序；特别是它不保证该顺序恒久不变
-
无索引，无法使用fori循环来遍历，可以使用增强for循环和迭代器来循环
-
造成内存泄露的原因：HashSet的remove方法也依赖于哈希值进行待删除节点定位，如果由于集合元素内容被修改而导致hashCode方法的返回值发生变更，那么，remove方法就无法定位到原来的对象，导致删除不成功，从而导致内存泄露。
-
HashSet：HashSet堪称查询速度最快的集合，因为其内部是以 HashCode 来实现的。它内部元素的顺序是由哈希码来决定的，所以它不保证set的迭代顺序
案例：
package set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetTest {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("b1111");
set.add("2222");
set.add("e3333");
set.add("4a444");
set.add("2222");
//HashSet有去重能力
System.out.println("HashSet元素的数量为：" + set.size());
//添加的顺序与遍历的元素顺序不一定一致
for (String s : set) {
System.out.println(s);
}
Iterator <String> iterator=set.iterator();
System.out.println("----------迭代器");
while(iterator.hasNext()){
System.out.println(iterator.next());
}
boolean bl=set.contains("e3333");
System.out.println(bl);
//清空
set.clear();
System.out.println("HashSet元素的数量为：" + set.size());
}
}
案例二（重点）如果只重写hashcode(),不重写equals()
package set;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetTest1 {
public static void main(String[] args) {
Set<Person> sets=new HashSet<>();
Person p1=new Person("jack",30);
Person p2=new Person("jim",25);
Person p3=new Person("luck",35);
//p1==p2比较的是地址值
System.out.println(p1==p2);
//equals比较两个对象是否相等，equals方法是object的方法，也就是任何对象都是这个方法，我们就重写equals来符合业务需求
System.out.println(p1.equals(p2));//false
//HashSet为什么优先选择 HashCode然后比较equals？
//因为HashCode计算和比较效率要高于equals比较
//hashset 怎么判断Person是不是同一个 首先判断person对象的hashcode是否相等（也就是哈希值）如果不相等 就认为不是同一个对象、
//如果hashcode 相等 再次判断equals是否返回true 如果返回true就认为是同一个对象 返回false就认为不是同一个对象
// 重写hashcode和equals的规则 equals相等 hashcode要相同、 hashcode相同equals不一定相同
// （例如：hashcode相等equals不同）
//添加到Set集合中
sets.add(p1);
sets.add(p2);
sets.add(p3);
System.out.println("sets当前的数量："+sets.size());//3
//修改p3的年龄
p3.setAge(30);
//删除不掉
Iterator iterator=sets.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next.hashCode());
}
sets.remove(p3);
System.out.println("sets当前的数量："+sets.size());//3
//再次添加p3，添加成功
sets.add(p3);
System.out.println("sets当前的数量："+sets.size());//4
for (Person p:sets){
System.out.println(p);
}
Iterator iterator1=sets.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next.hashCode());
}
}
}
package set;
public class Person {
private String name;
private int age;
public Person(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 hashCode() {
return name.hashCode()+age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
false
false
sets当前的数量：3
105255
3333071
3254269
sets当前的数量：3
sets当前的数量：4
Person{name='jim', age=25}
Person{name='luck', age=30}
Person{name='jack', age=30}
Person{name='luck', age=30}
105255
3333071
3254269
3333071我们会看到使用set.remove(p3)时，删除不掉p3，原因是使用p3.setAge(30)修改了他的年龄，随之他的地址值也会改变，而我并没有重写equals方法，它默认使用Object中的equals方法，所以找不到原来的地址，以至于删除不去了（我们使用hashset的时候他会默认使用equals方法和equals方法）。
解决办法：
package set;
public class Student {
private String no;
private String name;
private int age;
public Student(String no, String name, int age) {
this.no = no;
this.name = name;
this.age = age;
}
public String getNo() {
return no;
}
// public void setNo(String no) {
// this.no = no;
// }
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 String toString() {
return "Student{" +
"no='" + no + '\'' +
", name='" + name + '\'' +
", age=" + age +
'}';
}
//如果两个学生那个学号相同认定同一个学生
//使用equals判断对象是否相等
@Override
public boolean equals(Object obj) {
Student otherStu=(Student) obj;
if (this.getNo()==null||otherStu.getNo()==null){
return false;
}
return this.getNo().equals((otherStu.getNo()));
}
//重写hashCode 适用hashset和hashmap
//equals相等hashcode必须相等，hashcode相等equals不一定相等
@Override
public int hashCode() {
//只有相同的学号字符串相等，hashcode也相同
//不同的字符串，hashcode有可能相同，不影响，因为hashset和hashmap
//盘算hash相等之后判断equals
return this.getNo().hashCode();
}
}
package set;
import java.util.HashSet;
import java.util.Set;
public class StudentHashSet {
public static void main(String[] args) {
Student s1=new Student("001","jack",20);
Student s2=new Student("002","jim",25);
Student s3=new Student("003","lucy",30);
//在业务看来s1和s5是相等的
Student s5=new Student("001","jack",20);
Student s4=s1;
//没有业务要求，s1,s2,s3是不相等对象（s1,s2,s3 内存地址不相等）
Set<Student> sets=new HashSet<>();
//怎么判断HashSet中s1,s2,s3是不相等的三个对象
//1.判断hashcode是否相等
//2.如果hashcode向法庭，就判断equals是否相等
s1.setAge(80);
s2.setAge(90);
s3.setAge(100);
// s1.setNo("004");//在业务上已经发生改变。s1不在是原来的学习，删除不掉
System.out.println(s1.hashCode());//没有修改年龄hashcode值：460141958
System.out.println(s2.hashCode());//没有修改年龄hashcode值：1163157884
System.out.println(s3.hashCode());//没有修改年龄hashcode值：1956725890
System.out.println(s4.equals(s1));//true
sets.add(s1);
sets.add(s2);
sets.add(s3);
sets.add(s5);
System.out.println("数量为"+sets.size());
sets.remove(s1);
System.out.println("数量为"+sets.size());
}
}
重写的equals会判断学号是否一样，来区分
1.2LinkedHashSet
-
LinkedHashSet继承自HashSet，它主要是用链表实现来扩展HashSet类，HashSet中条目是没有顺序的，但是在LinkedHashSet中元素既可以按照它们插入的顺序排序，也可以按它们最后一次被访问的顺序排序
-
保持Set中元素的插入顺序或者访问顺序，就使用LinkedHashSet
案例：
package set;
import sun.awt.image.ImageWatched;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
public class LinkedHashSetTest {
public static void main(String[] args) {
List<String> list=new ArrayList<>();
list.add("a");
list.add("a");
list.add("b");
list.add("a");
list.add("c");
list.add("d");
list.add("b");
list.add("d");
list.add("c");
//要求list去重，又保证顺序
LinkedHashSet<String> lhs=new LinkedHashSet<>();
lhs.addAll(list);
for (String s: lhs){
System.out.println(s);
}
}
}
1.3TreeSet
-
TreeSet特点：无序不重复，但是可排序。 线程不安全（不同步）。底层基于TreeMap实现。
-
使用元素的自然顺序（字典顺序）进行排序：
-
存储非自定义对象(必须本身已经实现Comparable的接口)，默认进行排序。
-
存储自定义对象(需要实现Comparable接口,重写compareTo方法)进行排序。
-
接口Comparable<T>
-
使用比较器进行排序：
可以使用外部比较器Comparator，灵活为类定义多种比较器，此时类本身不需要实现Comparable接口；
案例：
package set;
import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
Teacher t1=new Teacher("jack",22,10);
Teacher t2=new Teacher("jim",28,14);
Teacher t3=new Teacher("lucy",50,24);
Teacher t4=new Teacher("laowang",25,16);
//创建TeachSet对象
Set<Teacher> sets=new TreeSet<>();
sets.add(t1);
sets.add(t2);
sets.add(t3);
sets.add(t4);
System.out.println("当前有："+sets.size());
for (Teacher t:sets){
System.out.println(t);
}
}
}
Comparable内比较器
package set;
public class Teacher implements Comparable<Teacher>{
private String name;
private int age;
private int level;
public Teacher(String name, int age, int level) {
this.name = name;
this.age = age;
this.level = level;
}
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 int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
//比较两个对象大小（通过年龄比大小）
//大于0 当前对象大于传入的对象o，小于0 当前对象小于传入的对象o
//等于0表示相等
@Override
public int compareTo(Teacher o) {
return o.age-this.age;
//return this.age-o.age;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
", level=" + level +
'}';
}
}
而它的对比过程是采用二叉树的方式去对比的
产生这个图的原因是我的修改器规则改变
compareTo()方法改变
排序变成了从大到小
变成了参数大于当前对象返回整数，返回0相等，参数小于当前对象返回负数
这个图才是二叉树原本的原理
排序是从小到大
通过debug可以得
jack比jack
jim比jack
lucy比jack
lucy比jim
laowang比jim
laowang比jack
扫一扫
231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
