摘要：

在java中集合主要分为两类，collection和map两个大的接口，collection又分为list和set接口，这里记录set接口的基本使用，供自己随时查看。

set的特点：

set存储的数据是无序的，不可重复的。set接口是collection的子接口，set接口没有提供额外的方法，set元素不允许包含相同的元素（无序不可重复），set判断两个对象是不是相等不是使用==运算符，而是根据equals方法

Set的主要实现类：

• HashSet（set接口是主要实现类，是线程不安全的，可以存储null值）
• LinkHashSet（是HashSet的子类，意思是在HashSet的基础上添加了前后指针，使其遍历时可以让他按照添加的顺序进行遍历，让他看起来像是有序一样，但实际是一种假象）
• TreeSet（底层是二叉树，具体一点就是红黑树（树结构本身就是有序的），他要求放入treeset中的对象是同一个类的对象，可以按照添加对象的指定属性进行排序）

set中常用的方法，Set接口没有提供额外的方法，因此set接口的操作方法都是在collection中定义的。

Set集合的基本使用示例

public class SetTest{
  @Test
  public void test() {
    Set set = new HashSet();
  
   set.add(456);
   set.add(123);
   set.add("AA");
   set.add("CC");
   set.add(new Person("tom", 123));
   set.add(123);
   set.add(new User("tom", 123));
   set.add(new User("name",123));
   Iterator iterator = set.iterator();
   while(iterator.hasNext()) {
          System.out.println(iterator.next());
    }
  }
}
// 打印的结果为：
AA
CC
Person{name='tom', age=123}
456
User{name='name', age=123}
123
User{name='tom', age=123}
set结构的无序性：
得到的结果并不是按照添加的顺序来的，然而这便不是巧合，
其实每次遍历的得到的结果都是这个值，并不是随机性的，
这是因为，虽然Set的数据最终也是通过数组存的
，但是在存储的时候并不是按照数组的索引来添加的，
而是根据数据的hash值来决定的，这就是set的无序性。
加的元素不是按照数组中的顺序一个个来的，而是通过魔种算法来确定添加的元素是
 再数组中的哪一个位置

set结构的不可重复性：
由例子中的结果可知，相同的元素并没有被添加到set中，这是set不可重复性的体现，就是相同的元素只能添加一个，具体的判断方案是equals()方法不能返回true,如果是则添加不进去。

向Set集合中添加元素的过程：

我们向HashSet中添加元素a，首先调用元素a所在类的hansCode方法，计算元素a的hash值，此hash值接着通过某种算法算出再HashSet底层数组中存放的位置（即为相应的索引位置），判断数组此位置上是否已经有元素，如果此位置没有元素，则元素小a直接添加成功，如果有其他元素b（或者以链表形式存在的多个元素，），则比较
元素a和b的hash值，若果hash值不相同，则元素a添加成功，如果hash相同，则需要调用元素a所再类的equals方法，如果返回true,则添加失败，如果返回false,则添加成功。

Set集合中注意事项：

• 1HashSet集合判断两个元素相等的标准是两个对象的hashCode方法比较 相等，并且两个对象的equals方法的返回值也是相等的。
• .2. 于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode方法。以实现对象的氙灯规则，即相等的对象必须有相等的散列码
• 3 LinkedHashSet是作为HashSet的子类，再添加数据的同时，每个数据还维护了两个引用，记录次数据的前一个数组和后一个数组，对于频繁的遍历操作，用LikedHashSet效率高
• 4 LinkedHashSet遍历时是按照添加的顺序遍历的，但是并不能说LinkedHashSet是有序的，因为LinkedHashSet在添加数据的时候还维护了两个引用。
• 5 之前提到Set中元素标胶相等是通过hashCode方法和equals方法来决定的，但是TreeSet作为Set接口的实现类却是一个例外。TreeSet比较相是更具排序来决定的，而且TreeSet中添加的元素是同一类型的元素，因为需要比较大小，如果不是同一类型的元素就没有办法比较大小，而且会报错。

两种常见的排序方式。

• 自然排序（实现Comparable接口）：比较两个对象是否相同的标准是：compareTo返回0
• 定制排序（和Comparator相关）：标胶两个对象是否相等的标准是：compare返回0
  如：

package com.liquan.exer;

import org.junit.Test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

/**
 * @auth nan
 * @create 2019-12-28 11:21
 */
public class SetDemo1 {

    /**
     * 在list内去除重复数字，要求尽量简单
     */

    @Test
    public void test(){

        List list = new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(3));
        list.add(new Integer(4));
        list.add(new Integer(4));
        HashSet set = new HashSet();

        set.addAll(list);

        List list2 = new ArrayList(set);

        for (Object integer: list2){
            System.out.println(integer);
        }

    }
}

Set集合使用的综合案例

• 利用Set的特性去重List

public class SetDemo1 {

    

    @Test
    public void test(){

        List list = new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(3));
        list.add(new Integer(4));
        list.add(new Integer(4));
        HashSet set = new HashSet();

        set.addAll(list); // 相同的元素是添加不进去的

        List list2 = new ArrayList(set);

        for (Object integer: list2){
            System.out.println(integer);
        }

    }
}

• 对于set无序和不可重复的加深理解案例

package com.liquan.exer;

import org.junit.Test;

import java.util.HashSet;



public class SetDemo2 {
    // 对于set一点先要equals
    @Test
    public void test(){
        Person p1 = new Person(1, "AA");
        Person p2 = new Person(2, "BB");

        HashSet set = new HashSet();

        set.add(p1);
        set.add(p2);

        System.out.println(set); // [Person{id=1, name='AA'}, Person{id=2, name='BB'}]

        p1.name = "CC";
        set.remove(p1);
        System.out.println(set); // 在重写hashCode和equals方法的前提下得到的是[Person{id=1, name='CC'}, Person{id=2, name='BB'}]
        // 因为remove在移除的时候判断存在才移除，判断存在则需要去找，更具hash值去找对应的位置，在移除前p1.name是CC,所以会用CC
        // 去得到一个hash值，此时得到的hash值和AA得到hash值不一样，此时根据这个hash值找到的内存地址并没有值，所以并没有真正意义上的
        // 删除。所以此时还是原来的两个值，只不过AA被换成了CC.

        set.add(new Person(1, "CC")); // 同样能添加成功

        System.out.println(set); // [Person{id=1, name='CC'}, Person{id=1, name='CC'}, Person{id=2, name='BB'}]
        // 因为添加的时候按CC去计算hash值，得到的hash值得地方并没有值存储，因此能添加成功

        set.add(new Person(1, "AA")); // 同样能添加成功
        System.out.println(set); // [Person{id=1, name='CC'}, Person{id=1, name='CC'}, Person{id=1, name='AA'}, Person{id=2, name='BB'}]

        // 因为虽然拿AA得到的hash值的地方有值，但是通过equals的时候CC和AA不一样，所以同样能添加成功。

    }
}