• Set不重复集，无序。
• Set不能通过下标获取指定的元素。因为所以没有下标。可以使用Iterator的方式迭代集合。若我们把List看成是有许多格子的盒子，那么Set就好像一个袋子。
• 常用实现类：
  HashSet：使用散列算法（哈希）实现Set集合。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
 * Set集合 无序且不重复集
 * 常用实现类：
 *      HashSet：使用散列算法（哈希）实现Set集合
 */
public class SetTest {
    public static void main(String[] args) {
        //实例化一个HashSet集合
        Set<String> set = new HashSet<String>();
        /**
         * 向集合中添加元素也使用add
         * 但是add方法不是向集合末尾追加元素，因为无序
         */
        set.add("One");
        set.add("Two");
        set.add("Three");
        /**
         * Set集合没有get(int index)方法
         * 我们不能像使用List那样，根据下标获取元素。
         * 想获取元素需要使用Iterator
         */
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String element = it.next();
            System.out.println(element);
        }
        /*
        * 宏观上讲：元素的顺序和存放顺序是不同的。
        * 但是在内容不变的前提下，存放顺序是相同的（使用相同的算法）。
        * 但是我们使用的时候，要当做是无序的使用。
        * */
        //使用For-Each循环遍历Set集合
        for (String element:set){
            System.out.println(element);
        }
    }
}

hashCode()方法

• hashCode()方法是Object定义的方法。所以每个类都会有该方法。若我们定义的类重写了equals()方法，就要重写hashCode()方法（Object提供的hashCode方法将返回该对象所在内存地址的整数形式）。
• 若equals方法返回true，那么这两个对象应该有相同的hashCode值，反过来不是必须的，当时最好是这样。可以提高诸如HashSet这样的数据结构的效率，一般情况下可以使用IDE提供的工具自动生成hashCode方法。

HashSet和hashCode方法的关系

• HashSet是Set接口的实现类，通过hash表的方式实现；在将对象加入HashSet集合中时，需要获取对象的hashCode值通过hash算法索引到对应的存储空间。
• 进行hash算法确定存储空间，当通过contains方法判断Set集合中是否包含某个对象是，需要首先根据对象的hashCode值索引到特定的空间，然后再和空间中的对象调用equals方法进行比较，这种查找方式不同于线性表的逐个比较，有很高的效率。

import java.util.HashSet;
import java.util.Set;
/**
 * hashCode
 */
public class HashTest {
    public static void main(String[] args) {
        Set<MyPoint> set = new HashSet<MyPoint>();
        set.add(new MyPoint(1,2));
        set.add(new MyPoint(3,4));
        /**
         * 查看新创建的对象是否在set中被包含
         * 虽然这里是新创建的对象，但是通过散列算法找到了位置后
         * 和里面存放的元素进行equals比较为true，所以依然认为
         * 是被包含的。
         */
        System.out.println(set.contains(new MyPoint(1,2)));//true
    }
}
class MyPoint{
    private int x;
    private int y;
    public MyPoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    /**
     *equals()和hashCode()方法我们一般让IDE帮我们自动生成
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyPoint point = (MyPoint) o;
        if (x != point.x) return false;
        return y == point.y;
    }
    /**
     * 若我们不重写hashCode，那么使用的就是Object提供的，
     * 该方法是返回句柄（对象存放地址）！换句话说，不同的对象hashCode不同
     * @return
     */
    @Override
    public int hashCode() {
        int result = x;
        result = 31 * result + y;
        return result;
    }
}

equals()方法和hashCode()方法对HashSet的影响

import java.util.HashSet;
import java.util.Set;
public class HashTest {
    public static void main(String[] args) {
        Set<MyPoint> set1 = new HashSet<MyPoint>();
        MyPoint p1 = new MyPoint(1,2);
        MyPoint p2 = new MyPoint(1,2);
        System.out.println("p1和p2是否为同一个对象"+(p1==p2));
        //重写equals方法和hashCode方法时的结果：false
        //重写equals方法未重写hashCode方法时的结果：false
        //未重写equals方法重写hashCode方法时的结果：false
        System.out.println("p1和p2内容是否一样"+p1.equals(p2));
        //重写equals方法和hashCode方法时的结果：true
        //重写equals方法未重写hashCode方法时的结果：true
        //未重写equals方法重写hashCode方法时的结果：false
        System.out.println("p1和p2的hashCode是否一样"+(p1.hashCode()==p2.hashCode()));
        //重写equals方法和hashCode方法时的结果：true
        //重写equals方法未重写hashCode方法时的结果：false
        //未重写equals方法重写hashCode方法时的结果：true
        set1.add(p1);
        set1.add(p2);
        System.out.println("hashset集合的元素数"+set1.size());
        //重写equals方法和hashCode方法时的结果：1
        //重写equals方法未重写hashCode方法时的结果：2
        //未重写equals方法重写hashCode方法时的结果：2
        System.out.println(set1);
        //重写equals方法和hashCode方法时的结果：[MyPoint{x=1, y=2}]
        //重写equals方法未重写hashCode方法时的结果：[MyPoint{x=1, y=2}, MyPoint{x=1, y=2}]
        //未重写equals方法重写hashCode方法时的结果：[MyPoint{x=1, y=2}, MyPoint{x=1, y=2}]
        /**
         * 当我们重写了Point的equals方法和hashCode方法后我们发现
         * 虽然p1和p2是两个对象，但是当我们将它们同时放入集合中时，
         * p2对象并没有被添加进集合。因为p1在放入后，p2放入时根据
         * p2的hashCode计算的位置中p2与该位置的p1的equals比较为true，
         * HashSet认为该对象已经存在，所有拒绝将p2存入集合。
         */
        /**
         * 若我们不重写MyPoint的hashCode方法，但是重写了equals方法。
         * 两个对象都可以放入HashSet集合中，因为两个对象具有不同的
         * hashCode值，那么当它们在放入集合时通过hashCode值进行
         * 散列算法结果就不相同，那么它们会被放入集合的不同位置。
         * 位置不相同，HashSet则认为他们不同，所有它们可以全部
         * 被存入集合。
         */
        /**
         * 若我们重写了hashCode但是不重写equals方法，
         * hashCode相同的情况下，在存放元素时，它们会在相同的位置，
         * HashSet会在相同的位置上将后放入的对象与该位置其它对象依次
         * 进行equals比较，若不相同，则将其存入。
         * 在同一个位置若干元素，这些元素会被放入一个链表中。
         * 由此可以看出。我们应该尽量使得所有类的不同对象的hashCode
         * 值不同。这样才可以提高HashSet在检索元素上的效率！
         * 否则可能检索效率还不如List。
         */
        /**
         * 结论：
         *      使用HashSet集合存放元素时
         *      应保证equals与hashCode方法在api上定义的要求
         * 存放规则：
         *      不同对象存放时，不会存放hashCode相同（存放位置相同）并且equals相同
         *      （内容相同）的
         *      对象。缺一不可，否则HashSet不认为它们是重复对象。
         */
    }
}
class MyPoint{
    private int x;
    private int y;
    public MyPoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    @Override
    public String toString() {
        return "MyPoint{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    /**
     *equals()和hashCode()方法我们一般让IDE帮我们自动生成
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyPoint point = (MyPoint) o;
        if (x != point.x) return false;
        return y == point.y;
    }
    /**
     * 若我们不重写hashCode，那么使用的就是Object提供的，
     * 该方法是返回句柄（对象存放地址）！换句话说，不同的对象hashCode不同
     * @return
     */
    @Override
    public int hashCode() {
        int result = x;
        result = 31 * result + y;
        return result;
    }
}