工具类：Colletions ，Arrays（静态导入，可变参数，强循环）

一、Collecti　　　　专门用来操作集合的工具类，没有构造函数，全静态方法。

　　　　常用方法：
　　　　　　static <T extends Comparable<? super T>> void sort(List<T> list) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　对一个元素自带比较方法的List集合排序。
　　　　　　static <T> void sort(List<T> list, Comparator<? super T> c) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　对一个元素不带比较方法的List集合排序（自己建立比较器。）

　　　　　　static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　对一个有序的List集合进行二分查找。
　　　　　　static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　对一个元素无排序方法进行二分查找。

　　　　　　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 <T> Comparator<T> reverseOrder() ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
　　　　　　static <T> Comparator<T> reverseOrder(Comparator<T> cmp) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　返回一个比较器，它强行逆转指定比较器的顺序。
　　　　　　　　　　　　　　　　　　　　　　　　　　　　这两个方法在集合建立的实参列表中传入,或者在sort语句中传入（因为返回的为比较器）。
　　

　　　　　　static void swap(List<?> list, int i, int j) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　在指定列表的指定位置处交换元素。
　　　　　　static <T> List<T> synchronizedList(List<T> list) ：
　　　　　　　　　　　　　　　　　　　　　　　　　　　　返回指定列表支持的同步（线程安全的）列表。（其他集合同有相应方式）

　　　　　　static void shuffle(List<?> list) ： 使用默认随机源对指定列表进行置换。
　　　　　　static void shuffle(List<?> list, Random rnd) ： 使用指定的随机源对指定列表进行置换。

二、Arrays
　　　　用于操作数组的工具类，没有构造函数，全静态方法。

　　　　常用方法：
　　　　　　static boolean deepEquals(Object[] a1, Object[] a2) ：如果两个指定数组彼此是深层相等 的，则返回 true。

　　　　数组变集合：
　　　　　　static <T> List<T> asList(T... a) ： 返回一个受指定数组支持的固定大小的列表。

　　　　　　好处：可以使用集合中的思想和方法类操作数组中的元素。

　　　　　　注意：1、返回的List集合中不能使用增删方法。因为数组长度不能改变，否则会发生异常。

　　　　　　　　　2、如果数组中的元素都是对象，转成集合时，会将数组中的元素直接转变成集合中的元素。
　　　　　　　　　　　　如果数组中的元素都是基本数据类型，那么就将数组本身当成元素存入集合。

　　　　　　　　　3、对于多维数组,<T>应当为低一级别的数组，传入集合的为数组的哈希码。

　　　　集合变数组：
　　　　　　使用的是Collection接口中的 ：

　　　　　　　　　　1、 Object[] toArray() 方法。
　　　　　　　　　　2、 <T> T[] toArray(T[] a) 方法。

　　　　　　对于方法一，返回的直接是一个Object类型的数组，其长度为集合的

　　　　　　对于方法二，如果作为实参传入的数组长度小于集合的size，那么方法内部会自动创建一个新数组，长的为size。
　　　　　　　　如果传入的数组长度大于集合的size，那么方法内部不会创建新的数组，而是使用传入的数组，不满位为null。
　　　　　　　　所以最好创建一个长度等于集合size的数组作为参数传入。

　　　　　　作用： 为了限定对元素的操作（元素个数不能再改变，即不能进行增删）。

三、强循环。

　　　　　　1、Iterable接口，实现该接口，将获得构建迭代器的方法（如：Collection）。

　　　　　　　　　　同时，实现这个接口还允许对象成为 "foreach" 语句的目标。（成为强循环语句的目标）

　　　　　　2、强循环语句格式： for（数据类型 变量名 ：被遍历的集合（Cellection）或者数组）{ }
　　　　　　　　　　　　　　如：for(String s : new ArrayList())
　　　　　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　　　　　(s 指向每次被遍历到的元素)
　　　　　　　　　　　　　　　　}
　　　　　　　　优点： 对集合数组进行遍历的时候，简化了书写。
　　　　　　　　缺点： 有较大的局限性：只能获取集合中的元素，不能对集合进行操作。

　　　　　　　　　　　　而迭代器除了能获取元素以外，还能remove集合中的元素（ListIterator甚至能添加集合中的元素）
　　　　　　　　　　　　而传统for语句更是功能强大， 除了特定情况建议使用传统for语句。

四、可变参数。

　　　　idk1.5 出现的新特性。

　　　　　　使用前提条件： 1、在定义形参列表的时候，可能会传入多个相同类型的参数（非硬性条件）
　　　　　　　　　　　　　 2、每个参数列表只能定义一个可变参数，并且要求放于参数列表的最后面。（硬性要求）

　　　　　　格式：
　　　　　　　　　　　　　　methed（参数类型1，参数类型2，..., 可变参数的参数类型...变量名）
　　　　　　  如：               method(String s, int i, Demo...d) :传一个字符串、一个整形、一个Demo类型的可变参数。

　　　　　　　　　　实现解释： 在调用方法传递参数时，到了Demo类型时，可以传入 多个 、一个或者 0 个参数。
　　　　　　　　　　　　　　　 底层会隐式的将对应参数封装成对应类型的数组，传入同类型参数个数就是数组长度。
　　　　　　　　　　　　　　　 之后在方法中遍历取出元素操作即可。

　　　　　　　如：      我们调用上述例子： method（"sd",8,demo1,demo2,demo3）；
                               实际接收参数为：s= "sd"; i = 8; Demo [] d = {demo1,demo2,demo3}

五、StaticImport 静态导入。

　　　　jdk1.5 出现的新特性。

　　　　　　为了能够使用其他的包中的类，我们可以导入这个类：
　　　　　　　　如： import java.util.*; :导入了java.util包中的所有类。

　　　　　　借助相同的原理，我们要使用其他的类中的静态成员时，可以静态导入这个类中的静态成员。
　　　　　　　　如： import static java.util.Collections.* ; :导入了Collections中的所有静态成员。
　　　　　　　　　　 import static java.util.Arrays.*; :导入了Arrays中所有的静态成员。
　　　　　　　　　　 import static Java.lang.System.*: : 导入了System中的所有静态成员。

　　　　　　好处： 再使用上述类中的导入后，使用这些类的静态成员时可以不用写类名

　　　　　　　　如： Collections.sort(List<T> list) 可以写为： sort(List<T> list);
　　　　　　　　　　Arrays.deepEequals(O[] o1, O[] o2); 可以写为 ： deepEquals(O[] o1, O[] o2);
　　　　　　　　　　System.out.println(); 可以写为： out.println();

　　　　　　注意： 前面学过，在包导入中，如果两个包中有相同名字的类，实例化该类的时候，必须指明包名。
　　　　　　　　　 同理，在类的静态导入之后，如果方法或成员重名时，应当指明方法所属的对象或者类名，
　　　　　　　　　 否则，系统按照就近原则查找。