day15(Collection类, 数据结构, Set接口)

第一章  Collections 类
    1.1 Collections常用功能
    常用方法:
        public static void shuffle(List<?> list): 打乱集合顺序;
        public static <T> void sort(List<T> list):根据元素的自然顺序 对指定列表按升序进行排序;
        public static<T> void sort(List<T> list, Comparator<? super T> ): 将集合中元素按照指定规则排序
    代码演示:
    
        public class CollectionsDemo {
            public static void main(String[] args) {
                ArrayList<Integer> list = new ArrayList<Integer>();
                
                list.add(100);
                list.add(200);
                list.add(10);
                list.add(50);
                list.add(500);
                list.add(1000);
                
                //排序方法
                Collections.sort(list);
                System.out.println(list);        
            }
        }    
        结果:
            [10,50,100,200,500,1000]
                
    1.2 Comparator 比较器
    
        //学生类
        public class Student{
            private String name;
            private int age;
            //构造方法
            //get/set
            //toString
        }
    
        //测试类
        public class Test02 {
            public static void main(String[] args) {
                // 创建四个学生对象 存储到集合中
                ArrayList<Student> list = new ArrayList<Student>();

                list.add(new Student("rose", 18));
                list.add(new Student("jack", 16));
                list.add(new Student("abc", 20));
                Collections.sort(list, new Comparator<Student>() {
                    @Override
                    public int compare(Student o1, Student o2) {
                        return o1.getAge() - o2.getAge();//以学生的年龄升序
                    }
                });
                for (Student student : list) {
                    System.out.println(student);
                }
            }
        }
        结果:    Student{name='jack', age=16}
                Student{name='rose', age=18}
                Student{name='abc', age=20}

第二章 数据结构  树
    树具有的特点:
        1.每个节点有零个或者多个子节点 node
        2.没有父节点的节点称之为根节点
        3.每一个非根节点有且只有一个父节点
        4.除了根节点外, 每个子节点可以分为多个不相交的子树
        
        | 名词     |                                 含义                          |
        | -------- | ------------------------------------------------------------ |
        | 节点     | 指树中的一个元素                                             |
        | 节点的度 | 节点拥有的子树的个数，二叉树的度不大于2                      |
        | 叶子节点 | 度为0的节点，也称之为终端结点                                |
        | 高度     | 叶子结点的高度为1，叶子结点的父节点高度为2，以此类推，根节点的高度最高 |
        | 层       | 根节点在第一层，以此类推                                     |
        | 父节点   | 若一个节点含有子节点，则这个节点称之为其子节点的父节点       |
        | 子节点   | 子节点是父节点的下一层节点                                   |
        | 兄弟节点 | 拥有共同父节点的节点互称为兄弟节点                           |

    二叉查找树
        二叉查找树的特点:
            1.左子树上所有的节点的值均小于等于他的根节点的值
            2.右子树上所有的节点值均大于或者等于他的根节点的值
            3.每一个子节点最多有两个子树
            
        红黑树的特性：
            1.每一个节点或是红色的，或者是黑色的。
            2.根节点必须是黑色
            3.每个叶节点(Nil)是黑色的；（如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点）
            4.如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
            5.对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点；        
                
第三章 set接口
    Set集合有多个子类，这里我们介绍其中的java.util.TreeSet、java.util.HashSet、java.util.LinkedHashSet这三个集合。
    特点:
        元素为一
    方法与Collection一致
    常用实现类:
        TreeSet  排序  唯一
        HashSet  无序  唯一
        LinkedHashSet   有序  唯一
        
    3.1 TreeSet集合
            集合特点:
                可以对集合中储存的数据进行排序, 并且保证元素的唯一. 
                但是如果想要对集合存储的元素进行排序的话, 要么存储的类型实现自然排序的接口Comparable, 
                    要么TreeSet集合在创建时, 使用比较器Comparator, 来指定比较的规则
            构造方法:
                public TreeSet();  构造一个新的空set, 该set根据其元素的自然顺序进行排序
                public TreeSet(Comparator<? super E> comparator);  构造一个新的空TreeSet, 它根据指定比较器进行排序
            
            代码演示:

public class Test {
                public static void main(String[] args) {
                    //Integer类实现了自然排序接口 所以可以直接使用
                    TreeSet<Integer>  set = new TreeSet<>();

                    set.add(20);
                    set.add(40);
                    set.add(30);
                    set.add(10);
                    set.add(10);
                    System.out.println(set);
                }
            }
            结果: [10,20,30,40]

        这是升序排列,并且去掉了重复元素.
        那么如果我们想降序排列,又不能修改Integer类,就可以在TreeSet的构造方法中传入比较器.
        
        代码演示:

public class Test {
                public static void main(String[] args) {
                    TreeSet<Integer>  set = new TreeSet<>(new Comparator<Integer>() {
                        @Override
                        public int compare(Integer o1, Integer o2) {
                            return Integer.compare(o2,o1);
                        }
                    });
                    set.add(20);
                    set.add(40);
                    set.add(30);
                    set.add(10);
                    set.add(10);
                    
                    System.out.println(set);
                }
            }    
            结果:[40,30,20,10]  

        
    3.2 HashSet集合
    
        java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不能保证不一致)。
        HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

        当存储自定义类型 如果想要保证元素唯一  必须重写hashCode方法和equals方法            
                
        HashSet添加元素原理:

 

        总结:
            HashSet集合添加元素时,先比较对象的HashCode
                                        不同  添加到集合
                                        相同  继续比较equals
                                                不同  添加到集合
                                                相同  不添加
            
        代码演示:
            

 public class Test01 {
                public static void main(String[] args){
                    Set<String> set = new HashSet<>();
                    
                    set.add("abc");
                    set.add("bcd");
                    set.add("abc");
                    
                    Sysrem.out.println(set);
                }
            }
            结果: [bcd,abc]    //无序  唯一

        
    3.3 LinkedHashSet集合
        在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构
        此实现与 HashSet的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。
        此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。
                
        代码演示:  

     

  public class LinkedHashSetDemo {
                public static void main(String[] args) {
                    Set<String> set = new LinkedHashSet<String>();
                    set.add("bbb");
                    set.add("aaa");
                    set.add("abc");
                    set.add("bbc");
                    Iterator<String> it = set.iterator();
                    while (it.hasNext()) {
                        System.out.println(it.next());
                    }
                }
            }
            结果：
                bbb
                aaa
                abc
                bbc