集合框架的工具类:collecttions

Collections 的方法全是静态的

       List没有排序功能，所以java定义了Collections工具类。

       比较器无法传给list，只能传给Set.但是集合工具类有此方法

1.排序：

       comparable:    sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。

       comparator:    sort(List<T> list, Comparator<? super T> c) 根据比较器产生的顺序对指定列表进行排序。

       swap(List<?> list, int i, int j)  在指定列表的指定位置处交换元素。

2.获取一堆对象中的最值：

       comparable:    max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。

       comparator:    max(Collection<? extends T> coll, Comparator<? super T> comp)

              根据指定比较器产生的顺序，返回给定 collection 的最大元素。

3.二分法：//元素必须有脚标，集合必须有序 返回脚标

       comparable:    binarySearch(List<? extends Comparable<? super T>> list, T key)

              使用二分搜索法搜索指定列表，以获得指定对象。

       comparator:    binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

               使用二分搜索法搜索指定列表，以获得指定对象。

4.复制

       void copy(List<? super T> dest, List<? extends T> src) 将所有元素从一个列表复制到另一个列表。

5.替换

       void fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。

   一替换多： boolean       replaceAll(List<T> list, T oldVal, T newVal)

        使用另一个值替换列表中出现的所有某一指定值。

        replaceAll(List<T> list, T oldVal, T newVal)

         用指定值替换列表中所有的oldValue 又是list

6.反转

       reverse(List<?> list) 又是集合

         反转指定列表中元素的顺序。                    

    反转比较器（相对于comparable）。代替了以前改变的obj>obj的“>”符号的方法。

        Comparator   reverseOrder();  逆转一个 实现comparable的对象的自然顺序。返回一个比较器。将它当做参数在传给treeSet即可      

       反转自定义的比较器（相对于compatator）。

              Comparator   reverseOrder(mycomp);将自定义的比较器进行强行逆转。

7.同步

       synchronizedSet(Set<T> s)  返回指定 set 支持的同步（线程安全的）set。

       原理：传入的集合的方法都被一个同步代码块（mutex），有用一个锁。

       可以对：Collction List Map Set等集合进行同步。

8.置换

       void swap(List<?> list, int i, int j) 在指定列表的指定位置(角标)处交换元素。

       shuffle(List<?> list) 使用默认随机源对指定列表进行置换。

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

       应用：对扑克牌的随机洗牌。

集合工具类：

Arrays:用于操作数组的工具类。全是静态方法。

         1.二分查找：binarySearch(T[] Key)

                    在指定范围内查找：binarySearch(double[],fromIndes,toIndes,Key);

         2.复制(截取)数组：copyOf(T[],int new length)，角标对应，数组相同，角标

         3.复制指定范围的数组。copyOfRangle(T[] original,int from,int to)

         4.asList(T...a):将数组变成集合（大小固定）。支持可变参数             

         5.toString(T[] t) ：返回字符串形式

         6.sort(T[] t)

                    sort(T[] t,fromindex,toindex):局部排序

         8.equals(T[] T,E[] e);元素数量相等，且对应的元素相同。

         7.deepEquasl和deepHashCode()：还比较元素的内容的元素。

数组变List集合

       static <T> List<T>  asList(T... a) :注意是List

              返回一个指定数组支持的固定大小的List集合。

       数组变成list集合的好处？

可以通过集合的思想和方法来操作数组中的元素,如：比如。list.contains(xxx);如果数组则要for循环判断，很麻烦。直接打印，替换,还有：get(),index,sublist等等。

       注意：将数组变成集合，不可以使用集合增删方法。 因为数组的长度是固定的。

              如果增删，则报unsupportedOperationException.

       如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。

       如果数组中的元素都是基本的数据类型，那么会将该数组作为集合中的元素存在。

集合变数组。

Collection 接口中的的toArray

        Object[] toArray()     返回包含此 collection 中所有元素的数组。

        <T> T[]  toArray(T[] a)  返回包含此 collection 中所有元素的数组；

        两种的区别。第二种可以限定元素类型，常用    

       数组变字符串：toString

 高级for:foreach

        格式：for(变量类型 变量 名:集合或数组){} ；高级for可以操作集合和数组。   

        2.与迭代器的区别：高级for无法对集合中的元素进行改变。这也是与iterator 和listIterator的本质区别

        2.与传统for的区别：高级for必须有被遍历的目标（它本质仍是从集中或数组取出来，仍是一个取出的动作），

              所以高级for无法进行打印"hello java"100次的等操作。。

        3.Map集合的高级for

        前提：先转成Set

        建议在遍历数组的时候，建议使用传统for,因为可以定义角标。

可变参数：jdk1.5版本出现的新特性。

       注意：可变参数一定要定义在参数列表的后面,后面不可以有别的参数。

       其实就是一种数组参数的简写形式,不用每一次都手动的建立数组对象。

       只要将要操作的元素作为了参数即可,隐式的将这些参数封装成了数组。

 public static void main(String[] args) {

              // TODO Auto-generated method stub

              show("a",1,6,5,6,7);

       }

       public static void show(String str,int in ,int...a){

              //System.out.println(a);//a是一个数组，其实就是封装了一个数组

              //怎么用 既然可变参数是数组，则调用数组的方法。

                     for(int x:a){

                     System.out.println("x"+x);

              }

              System.out.println(str+" "+in);//String不能放在最后。因为它会把后面的都打包，容易混乱。

              //System.out.println(Arrays.asList(a));忘了asList的条件。

              //记住；这两个例子是有区别的，有什么区别？没报错a,存储都是数组对象。 

              List li = Arrays.asList(a);

              List<int[]> li1 = Arrays.asList(a);

              //异常System.out.println(li.subList(0, 2));只有一个元素，角标越界。

              System.out.println(li1.size());