2022.4.25 集合Set子接口及其实现类

Set子接口

特点：无序、无下标、元素不可重复

方法：全部继承自Collection中的方法

增、删、遍历、判断与collection一致

 package com.xing.set;
 ​
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 ​
 public class Demo01 {
     public static void main(String[] args) {
         //Set为接口，只能实例化其下面的实现类
         Set<String> set = new HashSet<>();//后面<>里的内容可以不写
         set.add("哈哈");//只能添加String类型
         set.add("呵呵");//只能添加String类型
         set.add("你好");//只能添加String类型
         System.out.println(set.size());
         System.out.println(set);
 ​
         //set.remove("哈哈");//不能通过角标删除   因为无序
 ​
         //遍历  增强for  迭代器
         Iterator<String> iterator = set.iterator();
         while (iterator.hasNext()) {
             System.out.println(iterator.next());
         }
     }
 }

​

HashSet实现类 【重点】

存储结构：哈希表（数组+链表+红黑树）

 package com.xing.set;
 ​
 import java.util.HashSet;
 import java.util.Set;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         HashSet<String> hashset = new HashSet<>();//后面<>里的内容可以不写
         hashset.add("哈哈");//只能添加String类型
         hashset.add("呵呵");
         hashset.add("你好");
         hashset.add("哈哈");//重复元素  不会输出
         System.out.println(hashset.size());
         System.out.println(hashset);
 ​
         //删除  清空
         //hashset.remove("哈哈");
 ​
         //遍历  增强for   迭代器
 ​
         //判断
     }
 }
 

存储过程（重复依据）

• 根据hashCode计算保存的位置，如果位置为空，直接保存，若不为空(说明存入元素重复)，执行equals方法进行确认，如果equals为true，则认为是重复，拒绝存入，否则形成链表

 package com.xing.set;
 ​
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         Student s1 = new Student("张三",20);
         Student s2 = new Student("李四",18);
         Student s3 = new Student("王五",22);
 ​
         HashSet<Student> hashset = new HashSet<>();//后面<>里的内容可以不写
         hashset.add(s1);
         hashset.add(s2);
         hashset.add(s3);
         //不重写方法能插入进去,因为重写了hashCode()与equals()方法  所以插入不进去
         hashset.add(new Student("张三", 20));
         System.out.println(hashset.size());
         System.out.println(hashset);//必须重写toString才能打印 否则打印地址
 ​
         //不重写方法不能删除,因为重写了hashCode()与equals()方法  可以删除
         hashset.remove(new Student("张三", 20));
     }
 }
 ​
 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 int hashCode() {
         int n1 = this.name.hashCode();
         int n2 = this.age;
         return n1+n2;
     }
 ​
     @Override
     public boolean equals(Object obj) {
         //1 判断是不是同一个对象
         if(this == obj){
             return true;
         }
         //2 判断是否为空
         if(obj == null){
             return false;
         }
         //3 判断是否是Student类型
         if(obj instanceof Student){
             Student s = (Student) obj;
             //4 比较属性
             if(this.name.equals(s.getName()) && this.age == s.getAge()){
                 return true;
             }
         }
         //5 不满足条件返回false
         return false;
     }
 }
 

 ​

TreeSet实现类

特点

• 基于排列顺序实现元素不重复

• 实现SortedSet接口，对集合元素自动排序

• 元素对象的类型必须实现Comparable接口，指定排序规则

• 通过CompareTo方法确定是否为重复元素

存储结构：红黑树

创建集合 TreeSet treeSet = new TreeSet<>()

添加元素 treeSet.add();

删除元素 treeSet.remove();

遍历 1. 增强for 2. 迭代器

判断 treeSet.contains();

 package com.xing.set;
 ​
 import java.util.TreeSet;
 ​
 public class Demo03 {
     public static void main(String[] args) {
         TreeSet<String> treeSet = new TreeSet<>();
         treeSet.add("aaa");
         treeSet.add("bbb");
         treeSet.add("ccc");
 ​
         System.out.println(treeSet.size());
         System.out.println(treeSet);//不是对象类型按一定排列顺序打印，对象类型必须重写toString
 ​
 //        treeSet.remove("aaa"); 
         //遍历  判断
 ​
     }
 }
 

Comparable接口

 package com.xing.set;
 ​
 import java.util.HashSet;
 import java.util.TreeSet;
 ​
 public class Demo03 {
     public static void main(String[] args) {
         Person p1 = new Person("张三",20);
         Person p2 = new Person("李四",18);
         Person p3 = new Person("王五",22);
 ​
         TreeSet<Person> treeSet = new TreeSet<>();
 ​
         treeSet.add(p1);
         treeSet.add(p2);
         treeSet.add(p3);
 ​
         //报错   TreeSet会对元素进行排序  但是Person对象有两个参数  不知以哪个为标准进行比较
         //所以元素必须实现Comparable接口   compareTo()方法返回值为0,认为是重复元素
         System.out.println(treeSet.size());
         System.out.println(treeSet.toString());//必须重写其toString 否则打印地址
 //        treeSet.remove(p1);
 //        treeSet.remove(new Person("张三",20););//重写方法后可以删除
 ​
     }
 }
 ​
 class Person implements Comparable<Person>{
     private String name;
     private int age;
 ​
     public Person() {
     }
 ​
     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 String toString() {
         return "Person{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 ​
     //重写接口中的方法   先按姓名比  再按年龄比
     @Override
     public int compareTo(Person o) {
         //当前对象的名字 与 传进来对象的名字比较
         int n1 = this.getName().compareTo(o.getName());
         int n2 = this.age - o.getAge();//年龄比较
         return n1 == 0 ? n2 : n1;//姓名n1相等则根据年龄n2比较  否则返回n1
     }
 }
 ​
 

Comparator接口

 package com.xing.set;
 ​
 import java.util.Comparator;
 import java.util.TreeSet;
 ​
 public class Demo04 {
     public static void main(String[] args) {
         //在创建集合时指定比较规则
         //Comparator接口  实现定制比较  抽象类是不能直接new的,必须有实现类
         TreeSet<Person1> treeSet = new TreeSet<>(new Comparator<Person1>() {//用匿名内部类作为实现接口
             @Override
             public int compare(Person1 o1, Person1 o2) {
                 int n1 = o1.getAge()- o2.getAge();
                 int n2 = o1.getName().compareTo(o2.getName());
                 return n1 == 0 ? n2 : n1;
             }
         });
 ​
         Person1 p1 = new Person1("xyz",20);
         Person1 p2 = new Person1("xyz",18);
         Person1 p3 = new Person1("lisi",22);
         Person1 p4 = new Person1("zhangsan",22);
 ​
         treeSet.add(p1);
         treeSet.add(p2);
         treeSet.add(p3);
         treeSet.add(p4);
 ​
         System.out.println(treeSet.size());//4
         System.out.println(treeSet.toString());//必须重写toString
 ​
     }
 }
 class Person1 {
     private String name;
     private int age;
 ​
     public Person1() {
     }
 ​
     public Person1(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 String toString() {
         return "Person1{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 }