Collections 包含的都是静态方法
                        排序：
                                static <T extends Comparable<? super T>> void sort(List<T> list)
                                                根据元素的自然顺序 对指定列表按升序进行排序。
                                static <T> void sort(List<T> list, Comparator<? super T> c)
                                                根据指定比较器产生的顺序对指定列表进行排序。
                        查找：
                                static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
                                static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
                                                使用二分搜索法搜索指定列表，以获得指定对象。
                                                如果搜索键包含在列表中，则返回搜索键的索引；
                                                否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点
                                max min等同上
                        替换：
                                static <T> void  fill(List<? super T> list, T obj)  使用指定元素替换指定列表中的所有元素。
                                static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值
                        反转：
                                static void reverse(List<?> list)  反转指定列表中元素的顺序
                                static void swap(List<?> list, int i, int j)  在指定列表的指定位置处交换元素。
                        置换（洗牌，骰子）
                                static void shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
                                static void shuffle(List<?> list, Random rnd)  使用指定的随机源对指定列表进行置换。

                               
                        逆转比较器：
                                static <T> Comparator<T> reverseOrder()
                                                返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
                                static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
                                                返回一个比较器，它强行逆转指定比较器的顺序。
                                       
                                               
                        线程问题：
                                自己加锁好麻烦  以下使用时一定要查API看建议
                                static <T> Collection<T> synchronizedCollection(Collection<T> c)
                                                  返回指定 collection 支持的同步（线程安全的）collection。
                                static <T> List<T> synchronizedList(List<T> list)
                                                  返回指定列表支持的同步（线程安全的）列表。
                                static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
                                                  返回由指定映射支持的同步（线程安全的）映射。
                                static <T> Set<T>  synchronizedSet(Set<T> s)
                                                  返回指定 set 支持的同步（线程安全的）set。
                                static <K,V> SortedMap<K,V>  synchronizedSortedMap(SortedMap<K,V> m)
                                                  返回指定有序映射支持的同步（线程安全的）有序映射。
                                static <T> SortedSet<T>  synchronizedSortedSet(SortedSet<T> s)
                                                  返回指定有序 set 支持的同步（线程安全的）有序 set。

                               
        Arrays 用于操作数组的工具类
                       
                                对应的是
                        查找：       
                                各种二分查找方法
                        截取：
                                copyOf
                                copyOfRange
                        比较：
                                equals
                                deepEquals 不光比较数组 还比较元素内容
                        替换：       
                                fill
                        哈希码
                                hashCode
                        排序
                                sort
                                还能局部排序
                        变成字符串：
                                toString
       
===================================================================       
        数组变集合，
                        Arrays：static <T> List<T>   asList(T... a)
                                返回一个受指定数组支持的固定大小的列表。
                        原因： 把数组转变为集合，可以用一些集合方法，比如contains
                       
                        注意：因为数组长度是固定的，所以不能使用集合中的增删，否则发生UnsupportedOperationException
                        泛型特点：
                                        如果数组中的元素都是对象，那么变成集合时，那么数组中的元素直接转变为集合中的对象，比如String
                                        如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在，如果是int数组，泛型写int[]
                                       
        集合变数组：Collection.toArray();
                        Object[] toArray()
                        <T> T[] toArray(T[] a)  返回包含此 collection 中所有元素的数组；
                                返回数组的运行时类型与指定数组的运行时类型相同。
                                        如果指定的数组能容纳该 collection，则返回包含此 collection 元素的数组。
                                        否则，将分配一个具有指定数组的运行时类型和此 collection 大小的新数组。
                                String[] y = x.toArray(new String[0]);
                        原因：集合变数组，为了限定对元素的操作，就不能增删了
       
===================================================================       
1.5新特性
        public static void show(int... arr){  
                System.out.println(arr.length);
        }
        main(){
                show(2,3,4,5,6,7,8,9);  //只要传元素就行了，不用new一个数组，隐世封装
        }
       
集合静态导入
        StaticImport
        每次使用工具类，都要写Collections. 或者Arrays.等等
        import static java.util.Arrays.*; 静态导入Arrays这个类中的所有静态成员
                当类名重名时，需要指定具体的包名
                当方法重名时，需要制定所属的对象或者类

看起来略费劲。。基础还是不好。。马克一下，继续努力