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

1、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) ： 使用指定的随机源对指定列表进行置换。





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

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




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

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

　　　　　　注意：一、返回的List集合中不能使用增删方法。由于数组长度不能改变，不然会发生异常。

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

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

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

　　　　　　　　　　一、 Object[] toArray() 方法。
　　　　　　　　　　二、 <T> T[] toArray(T[] a) 方法。

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

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

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

3、强循环。

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

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

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

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



4、可变参数。

　　　　idk1.5 出现的新特性。

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

　　　　　　格式：
　　　　　　　　　　　　　　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}

 

5、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(); 　　　　　　注意： 前面学过，在包导入中，若是两个包中有相同名字的类，实例化该类的时候，必须指明包名。 　　　　　　　　　 同理，在类的静态导入以后，若是方法或成员重名时，应当指明方法所属的对象或者类名， 　　　　　　　　　 不然，系统按照就近原则查找。