【原】Java学习笔记028 - 集合

 package cn.temptation;

 import java.util.HashSet;
 import java.util.Set;

 public class Sample01 {
     public static void main(String[] args) {
         /*
          * 接口 Set<E>：一个不包含重复元素的 collection。
          *
          * 特点：
          * 1、无序：指的是Set显示其元素的顺序 与 放入元素的顺序可能不一致
          * 2、唯一：放入其中的元素是唯一的
          */

         Set<String> set = new HashSet<>();

         set.add("China");
         set.add("USA");
         set.add("Japan");
         set.add("China");

         System.out.println("set:" + set);        // set:[USA, China, Japan]

         // 通过查看源码，发现会使用到元素的hashCode，hashCode相同的字符串添加时不重复添加
         System.out.println("China".hashCode());        //
         System.out.println("USA".hashCode());        //
         System.out.println("Japan".hashCode());        //
         System.out.println((new String("China")).hashCode());        //
     }
 }
 // 查看HashSet类的源码
 //public boolean add(E e) {
 //    return map.put(e, PRESENT)==null;
 //}

 //private transient HashMap<E,Object> map;

 // 查看HashMap类的源码
 //public V put(K key, V value) {
 //    return putVal(hash(key), key, value, false, true);
 //}

 package cn.temptation;

 import java.util.HashSet;
 import java.util.Set;

 public class Sample02 {
     public static void main(String[] args) {
         // 类 HashSet<E>：此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。
         // 它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

         Set<Student> set = new HashSet<>();

         set.add(new Student("张三", 18));
         set.add(new Student("李四", 20));
         set.add(new Student("王五", 22));
         set.add(new Student("张三", 18));

         // 分析：观察一下创建相同姓名、相同年龄的学生对象，它们的hashCode是否一致
         // 原因在于因为Student类的对象没有重写hashCode方法和equals方法，默认使用Object类的hashCode方法和equals方法

         System.out.println((new Student("张三", 18)).hashCode());        // 未重写时的值：118352462            重写后的值：776408
         System.out.println((new Student("张三", 18)).hashCode());        // 未重写时的值：1550089733            重写后的值：776408

         System.out.println("set:" + set);
     }
 }

 package cn.temptation;

 import java.util.LinkedHashSet;
 import java.util.Set;

 public class Sample03 {
     public static void main(String[] args) {
         /*
          * 类 LinkedHashSet<E>：具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。
          *
          * 特点：有序唯一
          * 1、唯一：通过哈希表来保证唯一
          * 2、有序：通过链表来保证元素的有序
          */
         Set<String> set = new LinkedHashSet<>();

         set.add("China");
         set.add("USA");
         set.add("Japan");
         set.add("China");
         set.add("France");
         set.add("England");

         System.out.println("set:" + set);
     }
 }

 package cn.temptation;

 import java.util.Set;
 import java.util.TreeSet;

 public class Sample04 {
     public static void main(String[] args) {
         /*
          * 类 TreeSet<E>：
          * 基于 TreeMap 的 NavigableSet 实现。
          * 使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
          *
          * 能够对其中的元素按照某种规则进行排序
          *
          * 某种规则：
          * 1、可以按照自然顺序规则
          * 2、可以按照自定义排序规则
          */

         // 1、自然排序规则
         Set<Integer> set1 = new TreeSet<>();

         set1.add(1);
         set1.add(3);
         set1.add(2);
         set1.add(4);

         System.out.println("treeset:" + set1);        // treeset:[1, 2, 3, 4]

         System.out.println("-------------------------------------------");

         Set<Character> set2 = new TreeSet<>();

         set2.add('j');
         set2.add('A');
         set2.add('v');
         set2.add('a');
         set2.add('G');
         set2.add('O');
         set2.add('o');
         set2.add('D');

         System.out.println("treeset:" + set2);        // treeset:[A, D, G, O, a, j, o, v]

         System.out.println("-------------------------------------------");

         Set<String> set3 = new TreeSet<>();

         set3.add("USA");
         set3.add("China");
         set3.add("Japan");
         set3.add("Chile");

         System.out.println("treeset:" + set3);        // treeset:[Chile, China, Japan, USA]

         System.out.println("-------------------------------------------");

         Set<String> set4 = new TreeSet<>();

         set4.add("张三");
         set4.add("李四");
         set4.add("王五");
         set4.add("张飞");

         System.out.println("treeset:" + set4);        // treeset:[张三, 张飞, 李四, 王五]        显然不是根据拼音的顺序

         System.out.println((int)'张' + " VS " + (int)'李' + " VS " + (int)'王');        // 24352 VS 26446 VS 29579
         System.out.println((int)'三' + " VS " + (int)'飞');                                // 19977 VS 39134
     }
 }

 package cn.temptation;

 import java.util.Set;
 import java.util.TreeSet;

 public class Sample05 {
     public static void main(String[] args) {
         // 可以按照自定义排序规则

         // 思路：
         // 考虑到Set容器中的元素是无序且唯一的，要让他们可以有顺序，其实就是让它们具备可比较的能力，即实现Comparable<T>接口

         /*
          * 接口 Comparable<T>：此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
          *
          * Comparable<T>接口的常用成员方法：
          * int compareTo(T o) ：比较此对象与指定对象的顺序。
          */

         Set<Student> set = new TreeSet<>();

         // 执行异常：java.lang.ClassCastException: cn.temptation.Student cannot be cast to java.lang.Comparable
         set.add(new Student("张三", 20));
         set.add(new Student("李四", 18));
         set.add(new Student("王五", 22));
         set.add(new Student("张飞", 20));

         for (Student item : set) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation;

 import java.util.Comparator;
 import java.util.Set;
 import java.util.TreeSet;

 public class Sample06 {
     public static void main(String[] args) {
         /*
          * 接口 Comparator<T>：
          * 强行对某个对象 collection 进行整体排序 的比较函数。
          * 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。
          * 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。
          */

         /*
          * TreeSet类的构造函数：
          * TreeSet(Comparator<? super E> comparator) ：构造一个新的空 TreeSet，它根据指定比较器进行排序。
          */

         // 创建比较器对象
         Comparator<Student> comparator = new StudentCompartor();

         Set<Student> set = new TreeSet<>(comparator);

         set.add(new Student("张三", 20));
         set.add(new Student("李四", 18));
         set.add(new Student("王五", 22));
         set.add(new Student("张飞", 20));

         for (Student item : set) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation;

 import java.util.Comparator;
 import java.util.Set;
 import java.util.TreeSet;

 public class Sample07 {
     public static void main(String[] args) {
         // 观察到TreeSet类的构造函数TreeSet(Comparator<? super E> comparator) ：构造一个新的空 TreeSet，它根据指定比较器进行排序。
         // 传入的是一个接口，所以考虑使用匿名内部类
         // 匿名内部类写法的优点：使用了匿名内部类，就不用再制作实现Comparator接口的实现类了

         Set<Student> set = new TreeSet<>(new Comparator<Student>() {
             @Override
             public int compare(Student student1, Student student2) {
                 // 首先按年龄的自然顺序
                 int resultAge = student1.getAge() - student2.getAge();

                 /*
                  * 其次按姓名的自然顺序
                  * 字符串的比较时，考虑使用String类的compareTo方法
                  * String类的常用成员方法：
                  * int compareTo(String anotherString) :按字典顺序比较两个字符串。
                  */
                 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge;

                 return result;
             }
         });

         set.add(new Student("张三", 20));
         set.add(new Student("李四", 18));
         set.add(new Student("王五", 22));
         set.add(new Student("张飞", 20));

         for (Student item : set) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation;

 import java.util.Set;
 import java.util.TreeSet;

 public class Sample08 {
     public static void main(String[] args) {
         Set<Integer> set = new TreeSet<>();

         set.add(1);
         set.add(5);
         set.add(4);
         set.add(2);
         set.add(3);

         for (Integer item : set) {
             System.out.println(item);
         }
     }
 }
 // 【TreeSet存储规则】
 // 第一个元素存储时，直接作为根节点存储
 // 从第二个元素开始，每个元素存储时从根节点开始比较
 //        如果比根节点大，就作为根节点的右侧
 //      如果比根节点小，就作为根节点的左侧
 //        如果相等，就无视
 // 【TreeSet取出规则】
 // 取出时，根据（前序遍历、中序遍历、后序遍历）
 // 从根节点开始，按照左、中、右的原则依次取出元素

 // 查看TreeSet类的源码
 //public boolean add(E e) {
 //    return m.put(e, PRESENT)==null;
 //}

 //private transient NavigableMap<E,Object> m;

 //查看TreeMap类的源码
 //public V put(K key, V value) {
 //    Entry<K,V> t = root;
 //    if (t == null) {
 //        compare(key, key); // type (and possibly null) check
 //
 //        root = new Entry<>(key, value, null);
 //        size = 1;
 //        modCount++;
 //        return null;
 //    }
 //    int cmp;
 //    Entry<K,V> parent;
 //    // split comparator and comparable paths
 //    Comparator<? super K> cpr = comparator;
 //    if (cpr != null) {
 //        do {
 //            parent = t;
 //            cmp = cpr.compare(key, t.key);
 //            if (cmp < 0)
 //                t = t.left;
 //            else if (cmp > 0)
 //                t = t.right;
 //            else
 //                return t.setValue(value);
 //        } while (t != null);
 //    }
 //    else {
 //        if (key == null)
 //            throw new NullPointerException();
 //        @SuppressWarnings("unchecked")
 //            Comparable<? super K> k = (Comparable<? super K>) key;
 //        do {
 //            parent = t;
 //            cmp = k.compareTo(t.key);
 //            if (cmp < 0)
 //                t = t.left;
 //            else if (cmp > 0)
 //                t = t.right;
 //            else
 //                return t.setValue(value);
 //        } while (t != null);
 //    }
 //    Entry<K,V> e = new Entry<>(key, value, parent);
 //    if (cmp < 0)
 //        parent.left = e;
 //    else
 //        parent.right = e;
 //    fixAfterInsertion(e);
 //    size++;
 //    modCount++;
 //    return null;
 //}

 package cn.temptation;

 // 注意：只定义Student类，放入到TreeSet集合中会产生执行异常：java.lang.ClassCastException: cn.temptation.Student cannot be cast to java.lang.Comparable
 //public class Student {
 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;
     }

     // 为了去除重复内容的对象，需要重写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;
     }

     @Override
     public String toString() {
         return "学生 [姓名为：" + name + ", 年龄为：" + age + "]";
     }

     // 需要重写compareTo方法进行比较
     // 制定比较的规则：先比较年龄的大小，年龄相同时比较姓名的顺序
     @Override
     public int compareTo(Student anotherStudent) {
         // 首先按年龄的自然顺序
         int resultAge = this.age - anotherStudent.age;

         /*
          * 其次按姓名的自然顺序
          * 字符串的比较时，考虑使用String类的compareTo方法
          * String类的常用成员方法：
          * int compareTo(String anotherString) :按字典顺序比较两个字符串。
          */
         int result = (resultAge == 0) ? this.name.compareTo(anotherStudent.name) : resultAge;

         return result;
     }
 }

 package cn.temptation;

 import java.util.Comparator;

 /**
  * 实现比较器的类
  * 这里没有在Student类上直接实现Comparator<T>接口，是因为Comparator<T>接口的compare方法比较的是两个对象
  *
  * Comparator<T>接口的常用成员方法：
  * 1、int compare(T o1, T o2) ：比较用来排序的两个参数。
  * 2、boolean equals(Object obj) ：指示某个其他对象是否“等于”此 Comparator。
  *
  * 注意：因为Object基类就有equals方法，所以不显式进行重写，就是使用Object基类的equals方法，不会提示语法出错
  */
 public class StudentCompartor implements Comparator<Student> {
     /*
      * 重写进行比较的方法
      * 制定比较的规则：先比较年龄的大小，年龄相同时比较姓名的顺序
      */
     @Override
     public int compare(Student student1, Student student2) {
         // 首先按年龄的自然顺序
         int resultAge = student1.getAge() - student2.getAge();

         /*
          * 其次按姓名的自然顺序
          * 字符串的比较时，考虑使用String类的compareTo方法
          * String类的常用成员方法：
          * int compareTo(String anotherString) :按字典顺序比较两个字符串。
          */
         int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge;

         return result;
     }
 }