【原】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());        // 65078583
        System.out.println("USA".hashCode());        // 84323
        System.out.println("Japan".hashCode());        // 71341030
        System.out.println((new String("China")).hashCode());        // 65078583
    }
}
// 查看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;
    }
}