功能：

  1. 集合工具类,提供操作集合的静态方法

 

知识摘要：

  1. Collections(注意不是Collection，而是Collections，多了一个s)
  2. 一个集合工具类,提供操作集合的静态方法
  3. 方法分类：常规操作（查找，最大，最小等）、排序、线程安全（同步）操作、不可变集合

 

程序演示： 放大

  1. package com.cxy.collection;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Arrays;  
  5. import java.util.Collections;  
  6. import java.util.HashMap;  
  7. import java.util.HashSet;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10. import java.util.Set;  
  11. import java.util.TreeSet;  
  12.   
  13. /** 
  14.  * @author cxy @ www.cxyapi.com 
  15.  */  
  16. public class CollectionsTest  
  17. {  
  18.     public static void main(String[] args)  
  19.     {  
  20.         List l=new ArrayList();  
  21.         l.add(100);  
  22.         l.add(-66);  
  23.         l.add(0);  
  24.         l.add(88);  
  25.           
  26.         System.out.println("list:"+l);  
  27.           
  28.         Collections.reverse(l);  
  29.         System.out.println("反转后的list:"+l);  
  30.           
  31.         Collections.shuffle(l);  //随机排序，洗牌  
  32.         System.out.println("乱序后的list:"+l);  
  33.           
  34.         Collections.swap(l, 1, 3);  
  35.         System.out.println("互换序号是1，3元素后的list:"+l);  
  36.           
  37.         Collections.sort(l);  //这里是个自然排序，更多排序内容请参见本博客中的《JAVA应用 之 排序》  
  38.         System.out.println("排序后的list:"+l);  
  39.           
  40.         Collections.binarySearch(l, 88); //二分查找，必须保证list处于有序状态，查询成功返回序号，查不到返回负数  
  41.   
  42.         System.out.println("list中最小的元素是："+Collections.min(l));  
  43.         System.out.println("list中最大的元素是："+Collections.max(l));  
  44.         //上面两个方法 是自然排序，当然您可以自己实现一个Comparator的实现类作为第二个参数，具体见《JAVA应用 之 排序》  
  45.           
  46.         l.add(88);  
  47.         //88（第二个参数）在list（第一个参数）出现过多少次  
  48.         System.out.println("88在list中出现了："+Collections.frequency(l, 88)+"次");  
  49.           
  50.         Collections.replaceAll(l, 88, 66); //将88用66去替代  
  51.         System.out.println("替代后的list:"+l);  
  52.           
  53.         Collections.fill(l, 66); //使用66（第二个参数）替换list中的所有元素。  
  54.         System.out.println("list所有元素都被替换成为66："+l);  
  55.           
  56.         //下面写法的意思是创建一个l这么大的l1，不这么写会报异常，因为copy的时候不会自动扩容  
  57.         List l1=new ArrayList(Arrays.asList(new Object[l.size()]));  
  58.         Collections.copy(l1, l);  
  59.         System.out.println("拷贝l的l1："+l1);  
  60.         System.out.println("l和l1是否相等？"+l.equals(l1));  
  61.         System.out.println("l和l1是否是一个引用？"+ (l==l1));  
  62.         l1=l;  
  63.         System.out.println("l和l1是否相等？"+l.equals(l1));  
  64.         System.out.println("l和l1是否是一个引用？"+ (l==l1));  
  65.         l1=new ArrayList(l); //这个是一个浅拷贝，l和l1的引用虽然不同，但是l和l1内部的元素引用还是一样的  
  66.         System.out.println("l和l1是否相等？"+l.equals(l1));  
  67.         System.out.println("l和l1是否是一个引用？"+ (l==l1));  
  68.         //上面的问题有些复杂 以后形成一个专题讲解  
  69.           
  70.         //创建一个类型安全的集合，下面的意思是这个集合只能是再添加Integer类型数据  
  71.         l.add("abc");  //现在还没事~  
  72.         try  
  73.         {  
  74.             Collections.checkedList(l, Integer.class).add("abc");  
  75.         }catch(Exception e)  
  76.         {  
  77.             System.out.println("类型安全操作后，当你再试图添加非Integer类型数据时 发生了异常");  
  78.         }  
  79.         System.out.println("======================");  
  80.           
  81.         /* 注意常用的这些集合（HashSet、HashMap、ArrayList、TreeMap、TreeSet、LinkedList等）， 
  82.          * 都不是线程安全的，如果您的程序是在多线程环境下 并且有可能会同时修改同一个集合，那么 
  83.          * 您就需要使用Collections.synchronizedXxx 方法来保证线程安全 
  84.          */  
  85.         List sl=Collections.synchronizedList(new ArrayList());  
  86.         Map sm=Collections.synchronizedMap(new HashMap());  
  87.         Set ss=Collections.synchronizedSet(new HashSet());  
  88.         Set sts=Collections.synchronizedSortedSet(new TreeSet());  
  89.           
  90.         /* 不可变集合（空集合、指定元素集合、不可变状态） 
  91.          * 1.使用Collections.emptyXxx 方法来创建一个不可变化的空集合 
  92.          * 2.空不可变集合的意义：不会因为赋值null那样带来不可预期的异常，个人理解就是初始化的最佳实践。 
  93.          * 3.指定元素集合：返回一个只包含指定元素的集合,同时也是不可变化的集合 
  94.          *   应用：创建一个不可变化的特殊对象集合，例如：管理员集合,这样这个管理员对象就可以拥有一些集合的方法了 
  95.          *       例如：我判断一些这个用户对象是否是管理员（adminList.contains(user)） 
  96.          * 4.不可变状态：获得这个集合的不可变试图（只读） 
  97.          * 3.这里之用list举例，其他集合类似 
  98.         */  
  99.         List<String> el=Collections.emptyList();  
  100.         System.out.println(el.isEmpty());  
  101.   
  102.         try  
  103.         {  
  104.             el.add("1");  //如果试图改变它 那么就会抛出UnsupportedOperationException异常  
  105.         }catch(Exception e)  
  106.         {  
  107.             System.out.println("UnsupportedOperationException");  
  108.         }  
  109.           
  110.         List<String> el1=null;  //通常我们可能习惯这样定义一个list  
  111.         try  
  112.         {  
  113.             el1.contains("abc");  //可能在某个地方我们不小心的这样用了（假设这个存在于一个低概率发生的地方）  
  114.         }catch(Exception e)  
  115.         {  
  116.             System.out.println("null异常");  
  117.         }  
  118.           
  119.         List<String> singletonL=Collections.singletonList("abcd");  
  120.         System.out.println(singletonL);  
  121.           
  122.         //通过下面的方式就能得到一个不可变化的（只读）集合（视图的感觉，官方其实也是这么介绍的）  
  123.         List<String> listView=Collections.unmodifiableList(l);  
  124.     }  
  125. }