Java基础-Collection之Set的实现

Collection体系：
|–List——特点：元素有序（指的是元素的存入和取出的顺序一致），元素可重复
–||–ArrayList——特点：底层是数组结构，查询快，增删慢；线程不同步，效率高
–||–Vector——特点：底层是数组结构，查询快，增删慢；线程同步，效率低（基本上已经被ArrayList替代）
–||–LinkedList——特点：底层是链表结构，增删快，查询慢；线程不同步，效率高
|–Set——特点：元素无序（指的是元素的存入和取出的顺序有可能不一致），元素唯一
–||–HashSet——特点：底层是哈希结构，线程不同步，无序，高效
–||–TreeSet——特点：底层是二叉树结构，线程不同步，可以对Set集合中的元素进行指定顺序的排序。（自然顺序或自定义排序）

前面已经学过了Collection体系中的List的实现子类了，今天将学习到的Set的实现子类以及一些重要的知识点总结一下

学习集合体系的标准：学习顶层，使用底层
在Set体系中，有两个实现子类：HashSet和TreeSet
首先，来学习一下Set这个顶层所具备的功能
通过查询API，我发现，Set体系中定义的功能完全和Collection中定义的功能一致，因此，就不在这里赘述了，直接使用：

学习Set集合无非是学习：
1、创建一个集合
2、创建元素对象
3、往集合里添加元素
4、遍历
A：迭代器
B：增强for

创建一个Set集合的方法，由于Set是一个接口，不能通过new来新建对象，我们可以通过下面三种方式来创建一个Set集合

// 创建集合对象         Collection<String> c = new HashSet<String>();         Set<String> set = new HashSet<String>();         HashSet<String> hs = new HashSet<String>();

以上三种方法，都可以创建一个Set的集合

由于，set体系中的方法和Collection中定义的方法一样，那么我们现在直接来走一遍学习集合的流程
创建集合、创建元素、添加元素、遍历
代码如下：

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

结果：

从结果可以看出，1、我们存储元素的顺序和取出来的顺序是不同的，这就印证了Set体系中的集合的元素是无序的
2、在程序中，我们添加了两个“world”字符串，但是在遍历的时候却没有两个“world”，这印证了Set集合中的元
素是唯一的。后面学习的HashSet和TreeSet会详细分析保证元素唯一是如何实现的。
HashSet是Set体系中的一个子实现类
特点：特点：底层是哈希结构，线程不同步，无序，高效
HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。
当元素的hashCode值相同时，才继续判断元素的equals是否为true。
如果为true，那么视为相同元素，不存。如果为false，那么存储。
如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。

HashSet存储字符串并遍历

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("java");        // 遍历        for (String s : hs) {            System.out.println(s);        }    }}

结果：

分析：
在HashSet中添加了两个“java”元素，但是输出来只有1个，是因为String类实现了hashCode（）和equals（）方法。
那么，现在问题来了，当我们要存储自定义的对象时，该如何保证HashSet中元素的唯一性呢？
我们都知道，当我们new出来多个对象时，往HashSet中添加时，每个对象的地址值都是不同的，那么就算我们有两个属性一模一样
的对象，HashSet仍然认为是两个不同的对象，但是现实生活中，我们就认为这是同一个对象，其中一个不应该添加进HashSet集合中。

图解HashSet保证元素唯一性：

上面我们说过，在HashSet里面，是通过元素（也就是我们现在的对象）hashCode（）和equals（）方法来保证元素的唯一性。那么我们该如何来实现这两个方法呢？
通过观看原码，我们发现这是一个相当复杂的过程，但是IDE给我们提供了最大的方便，可以一键生成hashCode（）和equals（）方法。在开发中，我们只需要自动生成就好了。

那么现在，我们现在来看一下，在没有实现这两个方法的时候，HashSet是不能保证元素唯一的情况

Student.java

public 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;    }}

HashSetDemo.java

public class HashSetDemo2 {    public static void main(String[] args) {        // 创建集合对象        HashSet<Student> hs = new HashSet<Student>();        // 创建元素对象        Student s1 = new Student("林青霞", 26);        Student s2 = new Student("张曼玉", 36);        Student s3 = new Student("周慧敏", 20);        Student s4 = new Student("林青霞", 26);        Student s5 = new Student("林青霞", 66);        Student s6 = new Student("林志玲", 16);        // 添加元素        hs.add(s1);        // 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());        }    }}

结果：

分析：
这里标红的两个元素，在我们看来就属于同一个对象，但是HashSet并没能识别出来，是因为在Student类里面，没有实现hashCode（）和equls（）方法。
下面我们改进一下代码，让HashSet在存储我们自定义对象的时候，能识别出来

改进版Student.java代码

public 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() {//      // return 0;//      /*//       * name:30,age:40//       * name:20,age:50//       *///      return this.name.hashCode() + this.age*13;//  }////  @Override//  public boolean equals(Object obj) {//      // System.out.println(this + "------------------------------" + obj);//      if (this == obj) {//          return true;//      }////      if (!(obj instanceof Student)) {//          return false;//      }////      Student s = (Student) obj;//      return this.name.equals(s.name) && this.age == s.age;//  }    @Override    public String toString() {        return "Student [name=" + name + ", age=" + age + "]";    }    @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;    }}

结果：

分析：
由于在Student类中，我们实现了hashCode（）和equals（）方法，那么在属性一样的Student对象情况下，只能添加一个。
学习完HashSet后，我们来学习一下TreeSet

TreeSet 最大的特点是可以对集合中的元素进行自然顺序的（字典顺序）或者自定义方式 排序。同时还保证元素的唯一性
图解TreeSet保证元素唯一性：

下面来重点讲解TreeSet实现对元素排序的两种方式：（这里主要是针对自定义对象的排序）
方式一：自定义所在的类实现Comparable接口，并且重写CompareTo方法。
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
方式二：比较器的使用。Comparator接口。这里有两种使用方法：1、自定义一个比较器，实现Comparator接口，重写其中的compare（）
方法；2、直接使用TreeSet的带参构造方法，并且在参数位置使用Comparator的一个自实现类，即匿名内部类。

先来学习下，TreeSet对String类型数据保持唯一性和排序的例子：
代码：

import java.util.TreeSet;/* * TreeSet可以对元素进行排序。 * 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。  */public class TreeSetDemo {    public static void main(String[] args) {        // 创建集合对象        TreeSet<String> ts = new TreeSet<String>();        // 创建并添加元素        ts.add("hello");        ts.add("world");        ts.add("java");        ts.add("abcde");        ts.add("zone");        ts.add("world");        // 遍历        for (String str : ts) {            System.out.println(str);        }    }}

结果：

分析：
1、元素输出的顺序和我们传入的顺序不一致，而且是按照一定的顺序来输出，是因为在存入的时候，就按照了自然顺序存入；
2、代码中，添加了两个“world”元素，但是只有一个被输出来，是因为第二个没有被添加进去。是如何实现的呢？
是因为在String类中，实现了Camparable接口，并且重写了compareTo方法。

这一点可以从原码中看出来

现在，我们要实现TreeSet存储自定义对象时，也保证元素唯一和排序

国际惯例：先看一下错误的示范：（对象所在的类，既没有实现Comparable接口，在创建TreeSet是，也没有使用带参构造方法，并且传入
Comparatoe的匿名内部类）
Student.java代码

public 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 compareTo(Student s) {    // // 需求是比较年龄    // int num = this.age - s.age;    // // 由于对象有多个成员变量，你不能根据其中的某一个决定其他的。    // // 当某一个相同的时候，你还需要判断其他的是不是也是相同的。    // int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;    // return num2;    // }    // 需求:我想按照姓名的长度排序，从小到大排序。怎么做?//  @Override//  public int compareTo(Student s) {//      // 姓名的长度//      int num = this.name.length() - s.name.length();////        System.out.println(num);//      // 很多时候，别人给我们的需求其实只是一个主要需要//      // 还有很多的次要需求是需要我们自己进行分析的。//      // 比较姓名的内容//      int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;//      // 继续分析，姓名长度和内容都相同的情况下，年龄还可能不一样呢?//      // 所以，当姓名长度和内容都相同的时候，我们在比较下年龄就好了//      int num3 = (num2 == 0) ? (this.age - s.age) : num2;//      return num3;//  }}

TreeSetDemo2.java代码

public class TreeSetDemo2 {    public static void main(String[] args) {        // 创建集合对象        TreeSet<Student> ts = new TreeSet<Student>();        // 创建元素对象        Student s1 = new Student("liudehua", 52);        Student s2 = new Student("chenglong", 60);        Student s3 = new Student("zhouxinchi", 44);        Student s4 = new Student("sunyanzi", 34);        Student s5 = new Student("linqingxia", 26);        Student s6 = new Student("linqingxia", 36);        Student s7 = new Student("linqing", 26);        Student s8 = new Student("linqingxia", 26);        // 添加元素        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());        }    }}

结果：

分析：
1、ClassCastException：类类型转换异常。这个异常，我们在继承的时候遇到过，发生的原因主要是，两个没有继承或者实现关系
的类进行类型转换。这里也一样，因为Student没有实现Comparable接口。
下面让Student实现Comparable接口，并且重写compareTo方法

Student.java代码

public class Student implements Comparable<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 compareTo(Student s) {    // // 需求是比较年龄    // int num = this.age - s.age;    // // 由于对象有多个成员变量，你不能根据其中的某一个决定其他的。    // // 当某一个相同的时候，你还需要判断其他的是不是也是相同的。    // int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;    // return num2;    // }    // 需求:我想按照姓名的长度排序，从小到大排序。怎么做?    @Override    public int compareTo(Student s) {        // 姓名的长度        int num = this.name.length() - s.name.length();//      System.out.println(num);        // 很多时候，别人给我们的需求其实只是一个主要需要        // 还有很多的次要需求是需要我们自己进行分析的。        // 比较姓名的内容        int num2 = (num == 0) ? (this.name.compareTo(s.name)) : num;        // 继续分析，姓名长度和内容都相同的情况下，年龄还可能不一样呢?        // 所以，当姓名长度和内容都相同的时候，我们在比较下年龄就好了        int num3 = (num2 == 0) ? (this.age - s.age) : num2;        return num3;    }}

TreeSetDemo2.java代码不变

结果：

分析：
1、结果中，数据实现了排序，也保证了元素的唯一性。主要规则，在compareTo（）方法中。
我们可以在该方法中，定义属于具体需要的具体规则。如按年龄大小，按名字长短等等。

下面，我用匿名内部类的方式，实现同样的功能。这次，Student类就不需要实现Comparable接口了
开发中，推荐使用该方法，因为，开发中有一个原则，对修改关闭，对实现开放。怎么理解呢？就是说在我们的具体类中，定义好就尽量不要
改动，因为可能这个类与其他若干个类有各种关系，修改了一个地方，可能影响到其他类的功能。

Student.java代码

public 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;    }}

TreeSetDemo2.java代码

/* * 比较器接口 Comparator。带参构造。 *  * 开发原则： *      对修改关闭，对扩展开放。 */public class TreeSetDemo {    public static void main(String[] args) {        // 创建集合对象        // public TreeSet(Comparator comparator)        // Comparator c = new MyComparator();        // TreeSet<Student> ts = new TreeSet<Student>(c);        // 两句写一句        // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());        // 匿名内部类        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {            @Override            public int compare(Student s1, Student s2) {                // 按年龄排序，从小到大                int num = s1.getAge() - s2.getAge();                // 次要条件                int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;                return num2;            }        });        // 创建元素对象        Student s1 = new Student("liudehua", 52);        Student s2 = new Student("chenglong", 60);        Student s3 = new Student("zhouxinchi", 44);        Student s4 = new Student("sunyanzi", 34);        Student s5 = new Student("linqingxia", 26);        Student s6 = new Student("linqingxia", 36);        Student s7 = new Student("linqing", 26);        Student s8 = new Student("linqingxia", 26);        // 添加元素        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());        }    }}

结果：

分析：
1、这样做可以实现同样的功能。
2、需要理解匿名内部类的使用。
Collection和Collections

区别：（面试题）    Collection:是Collection集合的顶层接口，定义了Collection集合的共性方法。    Collections:是一个类，定义了针对Collection集合操作的功能。有排序，查找，反转等。

Collections的功能：
排序：public static void sort(List list)
二分查找：public static int binarySearch(List list,T key)
反转：public static void reverse(List list)
最大值：public static T max(Collection coll)
随机置换：public static void shuffle(List list)

马上使用之：
代码：

public class CollectionsDemo {    public static void main(String[] args) {        // 创建集合对象        ArrayList<Integer> array = new ArrayList<Integer>();        // 添加元素        array.add(60);        array.add(25);        array.add(38);        array.add(213);        array.add(99);        array.add(22);        System.out.println("array:" + array);        // 排序        // public static void sort(List list)        // Collections.sort(array);        // System.out.println("array:" + array);        // 二分查找        // public static <T> int binarySearch(List list,T key)        // [22, 25, 38, 60, 99, 213]        // int index = Collections.binarySearch(array, 60);        // System.out.println("index:" + index);        // 反转        // public static void reverse(List list)        // [60, 25, 38, 213, 99, 22]        // Collections.reverse(array);        // System.out.println("array:" + array);        // 最大值        // public static T max(Collection coll)        // Integer i = Collections.max(array);        // System.out.println(i);        // 随机置换：public static void shuffle(List list)        Collections.shuffle(array);        System.out.println("array:" + array);    }}

有了Collections的随机置换功能，我们可以模拟一下斗地主发牌的功能
代码

/* * 斗地主： *      模拟斗地主发牌 *  *  思路： *      买牌 *          黑桃A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K *          红桃A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K *          梅花A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K *          方块A、2、 3、 4、 5、 6、 7、 8、 9、 J、 Q、 K *          大王、小王 *      洗牌 *          利用Collections 的随机置换方法 *      发牌 *          发给3个人 *      看牌   *          留三张 */import java.lang.reflect.Array;import java.util.ArrayList;import java.util.Collections;public class DouDiZhu {    public static void main(String[] args) {        // 创建一个数组,表示花色        String[] colors = { "黑桃", "红桃", "梅花", "方块" };        // 创建一个表示数字的数组        String[] number = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };        // 造一个牌盒        ArrayList<String> array = new ArrayList<String>();        // 想把大小王装进去        array.add("大王");        array.add("小王");        // 增强for循环装牌        for (String c : colors) {            for (String n : number) {                // 组合牌                String s = c + n;                // 装牌                array.add(s);            }        }        // 打印一下牌        // System.out.print(array);        // 洗牌        Collections.shuffle(array);        // 打印一下洗牌后的牌        // System.out.print(array);        // 发牌,3个人,定义3个集合        ArrayList<String> weiweiList = new ArrayList<String>();        ArrayList<String> minminList = new ArrayList<String>();        ArrayList<String> guangtouList = new ArrayList<String>();        // 循环发牌,由于需要留三张牌,所以只能循环到array.size()-3        for (int x = 0; x < array.size()-3; x++) {            // 轮着发三张            if (x % 3 == 0) {                // 给第一个人发牌                weiweiList.add(array.get(x));            } else if (x % 3 == 1) {                // 给第二个人发牌                minminList.add(array.get(x));            } else if (x % 3 == 2) {                // 给第三个人发牌                guangtouList.add(array.get(x));            }        }        // 打印一下三个人手上的牌        System.out.println("weiweiList " + weiweiList);        System.out.println("minminList " + minminList);        System.out.println("guangtouList " + guangtouList);        //看底牌        //由于前面发牌的动作只到集合的size()-3,所以剩下三张        //这三张牌,使用ArrayList的get(index)方法获取,那么下标应该从array.size()-3开始,到array.size()        System.out.println("底牌是: ");        for(int x=array.size()-3; x<array.size(); x++){            //打印底牌出来            System.out.print(array.get(x)+ "  ");        }        System.out.println("要叫地主吗?");    }}

结果：

不分析了，大家看看哪一家会赢！！！