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

Set子接口

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

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

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

 1  package com.xing.set;
 2  
 3  import java.util.HashSet;
 4  import java.util.Iterator;
 5  import java.util.Set;
 6  
 7  public class Demo01 {
 8      public static void main(String[] args) {
 9          //Set为接口，只能实例化其下面的实现类
10          Set<String> set = new HashSet<>();//后面<>里的内容可以不写
11          set.add("哈哈");//只能添加String类型
12          set.add("呵呵");//只能添加String类型
13          set.add("你好");//只能添加String类型
14          System.out.println(set.size());
15          System.out.println(set);
16  
17          //set.remove("哈哈");//不能通过角标删除   因为无序
18  
19          //遍历  增强for  迭代器
20          Iterator<String> iterator = set.iterator();
21          while (iterator.hasNext()) {
22              System.out.println(iterator.next());
23          }
24      }
25  }

HashSet实现类【重点】

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

 1  package com.xing.set;
 2  
 3  import java.util.HashSet;
 4  import java.util.Set;
 5  
 6  public class Demo02 {
 7      public static void main(String[] args) {
 8          HashSet<String> hashset = new HashSet<>();//后面<>里的内容可以不写
 9          hashset.add("哈哈");//只能添加String类型
10          hashset.add("呵呵");
11          hashset.add("你好");
12          hashset.add("哈哈");//重复元素  不会输出
13          System.out.println(hashset.size());
14          System.out.println(hashset);
15  
16          //删除  清空
17          //hashset.remove("哈哈");
18  
19          //遍历  增强for   迭代器
20  
21          //判断
22      }
23  }
24

存储过程（重复依据）

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

 1  package com.xing.set;
 2  
 3  import java.util.HashSet;
 4  import java.util.Objects;
 5  import java.util.Set;
 6  
 7  public class Demo02 {
 8      public static void main(String[] args) {
 9          Student s1 = new Student("张三",20);
10          Student s2 = new Student("李四",18);
11          Student s3 = new Student("王五",22);
12  
13          HashSet<Student> hashset = new HashSet<>();//后面<>里的内容可以不写
14          hashset.add(s1);
15          hashset.add(s2);
16          hashset.add(s3);
17          //不重写方法能插入进去,因为重写了hashCode()与equals()方法  所以插入不进去
18          hashset.add(new Student("张三", 20));
19          System.out.println(hashset.size());
20          System.out.println(hashset);//必须重写toString才能打印 否则打印地址
21  
22          //不重写方法不能删除,因为重写了hashCode()与equals()方法  可以删除
23          hashset.remove(new Student("张三", 20));
24      }
25  }
26  
27  class Student {
28      private String name;
29      private int age;
30  
31      public Student() {
32      }
33  
34      public Student(String name, int age) {
35          this.name = name;
36          this.age = age;
37      }
38  
39      public String getName() {
40          return name;
41      }
42  
43      public void setName(String name) {
44          this.name = name;
45      }
46  
47      public int getAge() {
48          return age;
49      }
50  
51      public void setAge(int age) {
52          this.age = age;
53      }
54  
55      @Override
56      public int hashCode() {
57          int n1 = this.name.hashCode();
58          int n2 = this.age;
59          return n1+n2;
60      }
61  
62      @Override
63      public boolean equals(Object obj) {
64          //1 判断是不是同一个对象
65          if(this == obj){
66              return true;
67          }
68          //2 判断是否为空
69          if(obj == null){
70              return false;
71          }
72          //3 判断是否是Student类型
73          if(obj instanceof Student){
74              Student s = (Student) obj;
75              //4 比较属性
76              if(this.name.equals(s.getName()) && this.age == s.getAge()){
77                  return true;
78              }
79          }
80          //5 不满足条件返回false
81          return false;
82      }
83  }
84

TreeSet实现类

特点

基于排列顺序实现元素不重复
实现SortedSet接口，对集合元素自动排序
元素对象的类型必须实现Comparable接口，指定排序规则
通过CompareTo方法确定是否为重复元素

存储结构：红黑树

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

添加元素 treeSet.add();

删除元素 treeSet.remove();

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

判断 treeSet.contains();

 1  package com.xing.set;
 2  
 3  import java.util.TreeSet;
 4  
 5  public class Demo03 {
 6      public static void main(String[] args) {
 7          TreeSet<String> treeSet = new TreeSet<>();
 8          treeSet.add("aaa");
 9          treeSet.add("bbb");
10          treeSet.add("ccc");
11  
12          System.out.println(treeSet.size());
13          System.out.println(treeSet);//不是对象类型按一定排列顺序打印，对象类型必须重写toString
14  
15  //        treeSet.remove("aaa"); 
16          //遍历  判断
17  
18      }
19  }
20

Comparable接口

 1  package com.xing.set;
 2  
 3  import java.util.HashSet;
 4  import java.util.TreeSet;
 5  
 6  public class Demo03 {
 7      public static void main(String[] args) {
 8          Person p1 = new Person("张三",20);
 9          Person p2 = new Person("李四",18);
10          Person p3 = new Person("王五",22);
11  
12          TreeSet<Person> treeSet = new TreeSet<>();
13  
14          treeSet.add(p1);
15          treeSet.add(p2);
16          treeSet.add(p3);
17  
18          //报错   TreeSet会对元素进行排序  但是Person对象有两个参数  不知以哪个为标准进行比较
19          //所以元素必须实现Comparable接口   compareTo()方法返回值为0,认为是重复元素
20          System.out.println(treeSet.size());
21          System.out.println(treeSet.toString());//必须重写其toString 否则打印地址
22  //        treeSet.remove(p1);
23  //        treeSet.remove(new Person("张三",20););//重写方法后可以删除
24  
25      }
26  }
27  
28  class Person implements Comparable<Person>{
29      private String name;
30      private int age;
31  
32      public Person() {
33      }
34  
35      public Person(String name, int age) {
36          this.name = name;
37          this.age = age;
38      }
39  
40      public String getName() {
41          return name;
42      }
43  
44      public void setName(String name) {
45          this.name = name;
46      }
47  
48      public int getAge() {
49          return age;
50      }
51  
52      public void setAge(int age) {
53          this.age = age;
54      }
55      @Override
56      public String toString() {
57          return "Person{" +
58                  "name='" + name + '\'' +
59                  ", age=" + age +
60                  '}';
61      }
62  
63      //重写接口中的方法   先按姓名比  再按年龄比
64      @Override
65      public int compareTo(Person o) {
66          //当前对象的名字 与 传进来对象的名字比较
67          int n1 = this.getName().compareTo(o.getName());
68          int n2 = this.age - o.getAge();//年龄比较
69          return n1 == 0 ? n2 : n1;//姓名n1相等则根据年龄n2比较  否则返回n1
70      }
71  }
72  
73

Comparator接口

 1  package com.xing.set;
 2  
 3  import java.util.Comparator;
 4  import java.util.TreeSet;
 5  
 6  public class Demo04 {
 7      public static void main(String[] args) {
 8          //在创建集合时指定比较规则
 9          //Comparator接口  实现定制比较  抽象类是不能直接new的,必须有实现类
10          TreeSet<Person1> treeSet = new TreeSet<>(new Comparator<Person1>() {//用匿名内部类作为实现接口
11              @Override
12              public int compare(Person1 o1, Person1 o2) {
13                  int n1 = o1.getAge()- o2.getAge();
14                  int n2 = o1.getName().compareTo(o2.getName());
15                  return n1 == 0 ? n2 : n1;
16              }
17          });
18  
19          Person1 p1 = new Person1("xyz",20);
20          Person1 p2 = new Person1("xyz",18);
21          Person1 p3 = new Person1("lisi",22);
22          Person1 p4 = new Person1("zhangsan",22);
23  
24          treeSet.add(p1);
25          treeSet.add(p2);
26          treeSet.add(p3);
27          treeSet.add(p4);
28  
29          System.out.println(treeSet.size());//4
30          System.out.println(treeSet.toString());//必须重写toString
31  
32      }
33  }
34  class Person1 {
35      private String name;
36      private int age;
37  
38      public Person1() {
39      }
40  
41      public Person1(String name, int age) {
42          this.name = name;
43          this.age = age;
44      }
45  
46      public String getName() {
47          return name;
48      }
49  
50      public void setName(String name) {
51          this.name = name;
52      }
53  
54      public int getAge() {
55          return age;
56      }
57  
58      public void setAge(int age) {
59          this.age = age;
60      }
61  
62      @Override
63      public String toString() {
64          return "Person1{" +
65                  "name='" + name + '\'' +
66                  ", age=" + age +
67                  '}';
68      }
69  }

posted @ 2022-04-28 14:48 暴躁C语言阅读(107) 评论(0) 收藏举报

刷新页面返回顶部

暴躁C语言