Set
- 元素是无序(存储顺序和取出顺序不一致),元素是唯一的，不可重复的
我们来看一下API

这里写图片描述

我们写一个简单的Demo看看它的元素是不是无序和唯一的

public class SetDemo { 
       public static void main(String[] args) {
           // 创建集合对象 
         Set<String> set = new HashSet<String>();
          // 创建并添加元素
         set.add("hello");
         set.add("java");
         set.add("world");
         set.add("java"); 
         set.add("world"); 
         // 增强for遍历 
         for (String s : set) {
               System.out.println(s); 
         } 
        //迭代器遍历 
        Iterator it = set.iterator(); 
        while(it.hasNext()){ 
                System.out.println(it.next()); 
        }
    }
}

我们先来看结果：

这里写图片描述

在这里想给大家说一个要注意的地方虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。

增强for
增强for:是for循环的一种。

  格式： 
           for(元素数据类型 变量 : 数组或者Collection集合) { 
                   使用变量即可，该变量就是元素 
           }

好处：简化了数组和集合的遍历。弊端：增强for的目标不能为null。如何解决呢?对增强for的目标先进行不为null的判断，然后在使用。

HashSet类

什么是HashSet？我们先来了解他的概述

HashSet类概述
- 不保证 set 的迭代顺序
- 特别是它不保证该顺序恒久不变。
HashSet如何保证元素唯一性
- 底层数据结构是哈希表(元素是链表的数组)
- 哈希表依赖于哈希值存储
- 添加功能底层依赖两个方法：
  - int hashCode()
  - boolean equals(Object obj)

public class HashSetDemo { 
      public static void main(String[] args) { 
          // 创建集合对象 
          HashSet<String> hs = new HashSet<String>(); 
         // 创建并添加元素 
          hs.add("hello");
          hs.add("world"); 
          hs.add("java"); 
          hs.add("world"); 
         // 遍历集合(这里可以用增强for也可以用迭代器，但是增强for比较简单点) 
          for (String s : hs) { 
               System.out.println(s); 
         } 
   }
}

输出结果：

这里写图片描述

为什么存储字符串的时候，字符串内容相同的只存储了一个呢?

我们可以查看add方法的源码，就可以知道这个方法底层依赖两个方法：hashCode()和equals()。

    步骤：
        首先比较哈希值
        如果相同，继续走，比较地址值或者走equals()
        如果不同,就直接添加到集合中 
    按照方法的步骤来说：
        先看hashCode()值是否相同
        相同:继续走equals()方法
        返回true： 说明元素重复，就不添加
        返回false：说明元素不重复，就添加到集合
        不同：就直接把元素添加到集合
    如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
    而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。

存储自定义对象

我们存储自定义对象，并保证元素的唯一性，
要求：如果两个对象的成员变量值都相同，则为同一个元素。

public class HashSetDemo { 
          public static void main(String[] args) { 
                 // 创建集合对象 HashSet<Student> 
                hs = new HashSet<Student>(); 
                 // 创建学生对象 
               Student s1 = new Student("朱婷", 22); 
               Student s2 = new Student("惠若琪", 22); 
               Student s3 = new Student("徐云丽", 21); 
               Student s4 = new Student("朱婷", 22); 
               Student s5 = new Student("郎平", 55); 
               Student s6 = new Student("郎平", 57); 
               // 添加元素 
               hs.add(s1); 
               hs.add(s2); 
               hs.add(s3);
               hs.add(s4);
               hs.add(s5);   
               hs.add(s6);
               // 遍历集合 
              for (Student s : hs) { 
                    System.out.println(s.getName() + "---" + s.getAge());
              }
    }
}
/** * 存储对象 */
public class Student { 
        private String name;
        private int age;
        public Student() { 
             super();
        }
       public Student(String name, int age) { 
             super(); 
             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;
   }
}

输出结果：

这里写图片描述

我们看输出结果，很明显不符合我的要求。因为我们知道HashSet底层依赖的是hashCode()和equals()方法。而这两个方法我们在学生类中没有重写，所以，默认使用的是Object类。这个时候，他们的哈希值是不会一样的，根本就不会继续判断，执行了添加操作。

所以我们要在Student类中重写hashCode()和equals()这两个方法
这两个方法都是重写的，不用自己去写

@Override 
public int hashCode() { 
        final int prime = 31; 
        int result = 1;
         result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());     
        return result;
 } 
@Override
 public boolean equals(Object obj) { 
       if (this == obj) return true; 
      if (obj == null) return false; 
      if (getClass() != obj.getClass()) return false;
      Student other = (Student) obj;
      if (age != other.age) return false;
      if (name == null) {    
          if (other.name != null) return false; 
     }  else if (!name.equals(other.name)) return false; 
     return true;
 }

LinkedHashSet类

概述
- 底层数据结构由哈希表和链表组成
- 由链表保证元素有序(存储和取出是一致)
- 由哈希表保证元素唯一性

public class LinkedHashSetDemo { 
        public static void main(String[] args) {
                // 创建集合对象
               LinkedHashSet<String> hs = new LinkedHashSet<String>();
               // 创建并添加元素
              hs.add("hello");
              hs.add("world");
              hs.add("java");
              hs.add("world");
              hs.add("java"); 
              // 遍历
              for (String s : hs) { 
                    System.out.println(s);
              }
     }
}

TreeSet类

概述
- 使用元素的自然顺序对元素进行排序
- 或者根据创建 set 时提供的 Comparator 进行排序
  - 所以排序有两种方式
    - 自然排序
    - 比较器排序
- 具体取决于使用的构造方法。

public class TreeSetDemo { 
      public static void main(String[] args) { 
        // 创建集合对象 
       // 自然顺序进行排序 
       TreeSet<Integer> ts = new TreeSet<Integer>(); 
      // 创建元素并添加
     // 20,18,23,22,17,24,19,18,24 
    ts.add(20); ts.add(18); ts.add(23); ts.add(22); ts.add(17); ts.add(24);    
   ts.add(19); ts.add(18); ts.add(24);
    // 遍历 
    for (Integer i : ts) { 
      System.out.println(i);
    }
  }
}

TreeSet是如何保证元素的排序和唯一性的
- 底层数据结构是红黑树(红黑树是一种自平衡的二叉树)

二叉树

那么二叉树是怎么把元素存进去，又是怎么取出来的呢？
如果你弄懂了这个问题，那么你就明白了二叉树了

我们先来了解元素是如何存储进去的？

第一个元素存储的时候，直接作为根节点存储。从第二个元素开始，每个元素从根节点开始比较比根节点元素大，就放在右边比根节点元素小，就放在左边相等的话就忽略。

我们以上面的存储的元素20,18,23,22,17,24,19,18,24来画一个图帮助大家理解

这里写图片描述

元素是如何取出来的呢？

从根节点开始，按照左、中、右的原则依次取出元素即可。

Comparator 排序

/* * 需求：请按照姓名的长度排序 */
public class TreeSetDemo { 
public static void main(String[] args) { 
// 创建集合对象
 TreeSet<Student> ts = new TreeSet<Student>();
 // 创建元素 
Student s1 = new Student("朱婷", 22); 
Student s2 = new Student("惠若琪", 22); 
Student s3 = new Student("徐云丽", 21); 
Student s4 = new Student("朱婷婷", 22);
 Student s5 = new Student("郎平", 55); 
Student s6 = new Student("林丹", 34); 
Student s7 = new Student("李宗伟", 33); 
Student s8 = new Student("阿杜", 23); 
// 添加元素 
ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); ts.add(s6); ts.add(s7); ts.add(s8); 
       // 遍历
       for (Student s : ts) { 
           System.out.println(s.getName() + "---" + s.getAge()); 
       } 
    }
}
/* * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口 */
public class Student implements Comparable<Student> { 
private String name; 
private int age;
 public Student() {
 super();
 } 
public Student(String name, int age) { 
super();
 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) { 
// 主要条件 姓名的长度 
int num = this.name.length() - s.name.length(); 
// 姓名的长度相同，不代表姓名的内容相同 
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
 // 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄 
int num3 = num2 == 0 ? this.age - s.age : num2; 
return num3; 
}
}

TreeSet集合保证元素排序和唯一性的原理
唯一性：是根据比较的返回是否是0来决定。
排序：
- A:自然排序(元素具备比较性)
  - 让元素所属的类实现自然排序接口 Comparable
- B:比较器排序(集合具备比较性)
  - 让集合的构造方法接收一个比较器接口的子类对象 Comparator

Java中Set集合、增强for、HashSet类、LinkedHashSet类、TreeSet类、二叉树、Comparator 排序

HashSet类

存储自定义对象

LinkedHashSet类

TreeSet类

二叉树

Comparator 排序

猜你喜欢