Collections集合工具类、Arrays工具类、其他常用类：System,Runtime,Date,Calendar,Math

http://blog.csdn.net/rock_ray/article/details/21276993

1. Collections集合工具类

Collections类是java.util包中的一个集合的工具类，此类中提供了一些操作集合的静态方法，扩展了集合本身的功能。

这个类中的方法都是静态的，不需要创建对象。

Collections和Collection的区别：

1，Collections是java.util包中的一个类，是针对集合的一个工具类，提供一些静态方法对集合操作，实现集合功能的扩展。

2，Collection是java.util包中的一个接口，是所有集合的父接口，继承于它的主要有Set集合和List集合，Collection中提供集合共性方法声明。

1.1 Collections工具类部分方法

Collections工具类中的部分方法：

sort(list)：sort方法对List集合进行排序（自然排序）。

sort(list, comparator)：用指定比较器，对List集合进行排序。

max(collection)：根据自然顺序，返回集合的最大值。

max(collection, comparator)：根据比较器顺序，返回集合的最大值。

binarySearch(list, key)：使用二分查找法搜索List集合，返回元素在集合中的位置，若不包含返回插入点，若超出则返回集合长度。

Collections工具类的代码示例：

[java]view plaincopy 
   
 import java.util.*;  
   
 class CollectionsDemo{  
     public static void main(String[] args){  
         binarySearchDemo();  
     }  
       
     public static void binarySearchDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
         Collections.sort(list); //给list集合排序  
           
         sop(list);  
           
         int index1 = Collections.binarySearch(list,"aaa"); //binarySearch()二分搜索，返回元素在集合中的索引。  
         sop("index1: "+index1);  
         int index2 = Collections.binarySearch(list,"aaaa");  
         sop("index2: "+index2);  
         int index3 = Collections.binarySearch(list,"zzz");  
         sop("index3: "+index3);  
           
         Collections.sort(list,new StrCom()); //用指定比较器给list集合排序  
         sop(list);  
           
         int index = Collections.binarySearch(list,"aaa",new StrCom());  //根据比较器顺序，找出索引。  
         sop("index: "+index);  
     }  
       
     public static void maxDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
           
         sop(list);  
           
         String max = Collections.max(list); //max方法返回集合的最大值（自然顺序），集合具备比较性，实现Comparable接口  
           
         sop("max: "+max);  
           
         String max1 = Collections.max(list,new StrCom()); //返回集合中的最大值（比较器顺序）  
           
         sop("max1: "+max1);  
     }  
       
     public static void sortDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
           
         sop(list);  
           
         Collections.sort(list);  //使用Collections工具类的sort()方法排序。自然顺序。  
           
         sop(list);  
           
         Collections.sort(list,new StrCom());  //比较器顺序。  
           
         sop(list);  
           
     }  
       
     public static void sop(Object obj){  
         System.out.println(obj);  
     }  
 }  
 class StrCom implements Comparator<String> {  
     public int compare(String s1,String s2){  
         if(s1.length()>s2.length())  
             return 1;  
         if(s1.length()<s2.length())  
             return -1;  
         return 0;  
     }  
 }  

1.2 Collections工具类部分方法

Collections工具类的部分方法：

fill(list, A)方法：把集合中的所有元素，替换成指定元素A。

replaceAll(List, A, B)方法：把集合中，所有的旧的指定元素A，替换成新的指定元素B。

reverse(list)方法：反转集合中元素的顺序。

swap(list, i, j)方法：交换List集合中，位置i和位置j的两个元素。

shuffle(list)方法：对集合进行重新随机排序。 shuffle：洗牌。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
   
 class CollectionsDemo2 {  
     public static void main(String[] args){  
         shuffleDemo();  
     }  
       
     public static void shuffleDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
         sop(list);  
           
         Collections.shuffle(list);   //对集合list中的元素，进行随机排序，即洗牌。  
         sop(list);  
     }  
       
     public static void reverseDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
         sop(list);  
           
         Collections.reverse(list);   //反转list集合中元素的顺序。  
         sop(list);  
     }  
       
     public static void replaceAllDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
         sop(list);  
           
         Collections.replaceAll(list,"aaa","pp");   //用"pp"替换集合list中的所有"aaa"。  
         sop(list);  
     }  
       
     public static void fillDemo(){  
         List<String> list = new ArrayList<String>();  
           
         list.add("abcd");  
         list.add("aaa");  
         list.add("z");  
         list.add("kkkkk");  
         list.add("qq");  
           
         sop(list);  
         Collections.fill(list,"pp");  //用"pp"替换集合list的所有元素。  
         sop(list);  
     }  
       
     public static void sop(Object obj){  
         System.out.println(obj);  
     }  
 }  

1.3 Collections工具类部分方法

Collections工具类的部分方法：

reverseOrder()：返回一个比较器Comparator，此比较器的顺序与自然顺相反，即反转了自然顺序。

reverseOrder(cmp)：返回一个比较器，此比较器的顺序与指定比较器cmp的顺序相反，即反转指定比较器的顺序。

synchronizedCollection(coll)方法：返回指定集合coll的线程同步（线程安全的）集合。

synchronizedList(list)方法：返回指定集合list的线程同步（线程安全的）集合。

synchronizedMap(map)方法：返回指定集合map的线程同步（线程安全的）集合。

synchronizedSet(set)方法：返回指定集合set的线程同步（线程安全的）集合。

原理：将集合的所有方法加同一把锁后返回，实现了线程同步。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
   
 class CollectionsDemo3 {  
     public static void main(String[] args){  
         reverseOderDemo_2();  
     }  
       
     public static void reverseOderDemo(){  
         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());  
                                                  //reverseOrder()返回比较器，其顺序是自然顺序的反顺序。  
         ts.add("a");  
         ts.add("bb");  
         ts.add("ccc");  
         ts.add("dddd");  
         ts.add("eeeee");  
           
         sop(ts);  
     }  
       
     public static void reverseOderDemo_2(){  
         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrCom()));  
                              //此处带参数的reverseOrder()返回比较器，其顺序是指定比较器的反顺序。  
         ts.add("a");  
         ts.add("bb");  
         ts.add("ccc");  
         ts.add("dddd");  
         ts.add("eeeee");  
           
         sop(ts);  
     }  
       
     public static void sop(Object obj){  
         System.out.println(obj);  
     }  
 }  
   
 class StrCom implements Comparator<String> {  //字符串长度由小到大排序。  
     public int compare(String s1,String s2){  
         if(s1.length()<s2.length())  
             return -1;  
         if(s1.length()>s2.length())  
             return 1;  
         return 0;  
     }  
 }  

2. Arrays工具类

java.util包中的Arrays类是操作数组的工具类，提供了一些静态方法。

数组变集合：

asList()：将数组变成List集合。

其他方法还有：equals()、deepEquals()、binarySearch()、copyOf()、copyOfRange()、fill()、hashCode()、sort()、toString()等等。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
   
 class ArraysDemo{  
     public static void main(String[] args){  
      /* int[] arr = {2,4,6}; 
          
         System.out.println(Arrays.toString(arr));  //返回指定数组内容。 */  
           
         String[] arr = {"abc","cc","kkkk"};  
           
         List<String> list = Arrays.asList(arr);   //把数组变成List集合，可以使用集合的思想和方法来操作数组。  
         sop("contains: "+list.contains("cc"));  
           
       //list.add("qq");  //注意：将数组变成集合，不可以使用集合的增删方法。  
         sop(list);       //因为，数组的长度是固定的。  
                          //如果你增删了，那么会发生UnsupportedOperationException异常。  
                            
         Integer[] nums = {4,5,3};  
         List<Integer> li = Arrays.asList(nums);  
           
         sop(li);   //如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。  
                    //如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。  
     }  
       
     public static void sop(Object obj){  
         System.out.println(obj);  
     }  
 }  

集合变数组：Collection接口中的toArray()方法。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
   
 class ArraysDemo2{  
     public static void main(String[] args){  
         ArrayList<String> al = new ArrayList<String>();  
           
         al.add("abc01");  
         al.add("abc02");  
         al.add("abc03");  
           
         /* 
         1，指定类型的数组到底要定义多长呢？ 
         当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。 
         所以创建一个刚刚好的数组最优。 
          
         2，为什么要将集合变数组？ 
         为了限定对元素的操作，不需要进行增删了。 
         */  
           
         String[] arr = al.toArray(new String[al.size()]);  
           
         System.out.println(Arrays.toString(arr));  
     }  
 }  

3. 其他常用类

3.1 System类

System类在java.lang包中，描述系统的一些信息。

System：类中的方法和属性都是静态的。

System.out：标准输出，默认是控制台。

System.in：标准输入，默认是键盘。

Properties getProperties()：获取系统属性信息。

Properties是Map集合的子类，通过调用System的getProperties方法返回。

getProperties()方法：确定当前的系统属性，返回 Properties。

getProperty(key)方法：获取指定键指示的系统属性。

代码示例：

[java]view plaincopy 
   
 import java.util.*; //Properties类在java.util包中  
   
 class SystemDemo{  
     public static void main(String[] args){  
         Properties prop = System.getProperties(); //获取Properties，系统属性信息。  
           
     /*  因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。 
         那么可以通过map的方法取出该集合中的元素。 
         该集合中存储的都是字符串，没有泛型定义。 */  
           
           
         //如何在系统中自定义一些特有信息呢？  
         System.setProperty("myKey","myValue"); //setProperty()方法在系统中自定义一些特有信息。  
           
         /* 
         //获取所有属性信息。 
         for(Object obj : prop.keySet()){ 
             String value = (String)prop.get(obj); 
              
             System.out.println(obj+"::"+value); 
         } */  
           
         //获取指定属性信息。  
         String value = System.getProperty("os.name");  
         System.out.println("value="+value);  
           
     /*  可不可以在 JVM 启动时，动态加载一些属性信息呢？ 
         运行时输入命令： java -D haha=qqqq SystemDemo 
         意思是添加“键值对”:<haha,qqqq>到系统信息中。 */  
         String v = System.getProperty("haha");  
         System.out.println("v="+v);  
     }  
 }  

3.2 Runtime类

Runtime类在java.lang包中。

该类中并没有提供构造方法。

说明不可以new对象，那么会想到该类中的方法都是静态的。

但是发现该类中还有非静态方法。

说明该类中肯定还会提供方法获取本类对象，而且该方法是静态的，并返回值类型是本类类型。

由这个特点可以看出该类使用了单例设计模式来完成。

该方法是 static Runtime getRuntime(); //返回Runtime类型的本类对象。

调用Runtime类型对象的exec()方法，返回一个Process进程对象，exec()方法是非静态的。

Process对象的静态方法destroy()可以杀掉进程。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
   
 class RuntimeDemo  {  
     public static void main(String[] args) throws Exception {  
         Runtime r = Runtime.getRuntime();  
         Process p = r.exec("calc.exe");  //execute，exec()方法执行指定命令，  
                                        //执行环境变量Path目录下的calc.exe程序（计算器）  
         Thread.sleep(2000);  
         p.destroy();  //杀掉进程。  
           
         Process pp = r.exec("notepad.exe SystemDemo.java");  //用notepad程序打开SystemDemo.java文件。  
                     //notepad 和 SystemDemo.java文件，都存放在环境变量Path目录下。  
     }  
 }  

3.3 Date类

Date类在java.util包中，Date类表示特定的瞬间，精确到毫秒。

SimpleDateFormat类对Date返回的日期进行格式化，便于观看。

调用SimpleDateFormat的format(date)方法对Date格式化。

SimpleDateFormat类在text包中。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
 import java.text.*;  
   
 class DateDemo{  
     public static void main(String[] args){  
         Date d = new Date();  //获取当前系统时间，精确到毫秒。  
         System.out.println(d);  //打印的时间看不懂，希望有些格式。  
           
         //将模式封装到SimpleDateFormat对象中。  
         SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日E hh:mm:ss");  
           
         //调用format方法让模式格式化指定Date对象。  
         String time = sdf.format(d);  
           
         System.out.println("time= "+time);  
     }  
 }  

3.4 Calendar类

Calendar在java.util包中，通过指定字段，获取相应时间，如果只想获取年份，则只需要YEAR字段。

getInstance()：获取一个Calendar实例，一个默认日历。

get(指定字段)：根据指定字段，获取时间。

set(日期)：设置当前日历为指定日期。

add(指定字段，增减量)：把日历中的指定字段，增加或删除指定时间。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
 import java.text.*;  
   
 class CalendarDemo{  //Calendar：日历  
     public static void main(String[] args) {  
         Calendar c = Calendar.getInstance();  //getInstance()获取一个默认日历。  
           
         sop(c.get(Calendar.YEAR)+"年");  //Calendar的get方法获取指定字段，  
                                          //YEAR字段是静态的，且在Calendar类中，需指明所属类。  
         sop((c.get(Calendar.MONTH))+1+"月");  
         sop(c.get(Calendar.DAY_OF_MONTH)+"日");  
         sop("星期"+c.get(Calendar.DAY_OF_WEEK));  
           
         //查表法  
         String[] mons = {"一月","二月","三月","四月","五月","六月","七月","八月","九月"  
                           ,"十月","十一月","十二月"};  
         int index = c.get(Calendar.MONTH);  
         sop(mons[index]);  
           
         c.set(2014,2,17);   //把当前日历的日期设为，2014年3月17日。  
         print(c);  
           
         c.add(Calendar.YEAR,-1);  //当前日历的年份，减少一年。  
         print(c);  
           
         /*  
         Date d = new Date(); 
         SimpleDateFormat sdf = new SimpleDateFormat("YYYY"); 
         String year = sdf.format(d); 
         System.out.println(year); */  
     }  
       
     public static void print(Calendar c){  
         sop(c.get(Calendar.YEAR)+"年");  
         sop((c.get(Calendar.MONTH))+1+"月");  
         sop(c.get(Calendar.DAY_OF_MONTH)+"日");  
     }  
       
     public static void sop(Object obj){  
         System.out.println(obj);  
     }  
 }  

3.5 Math类和Random类

Math类在java.lang包中。

Math类中提供了一些常用的方法，

例如，random方法产生随机数，ceil方法返回大于指定数的最小整数，floor方法返回小于指定数的最大整数，round方法返回指定数的四舍五入，pow方法进行幂运算。

代码示例：

[java]view plaincopy 
   
 class MathDemo{  
     public static void main(String[] args){  
         for(int x=0; x<10; x++){  
             double d3 = Math.random();  //随机大于等于0且小于1的随机double值。  
             sop(d3);  
         }  
     }  
       
     public static void show(){  
         double d = Math.ceil(-16.34);  //ceil方法返回大于指定数据的最小整数。  
         double d1 = Math.floor(12.34);  //floor方法返回小于指定数据的最大整数。  
           
         long l = Math.round(12.54);  //round方法返回指定数据的四舍五入。  
         sop("d="+d);  
         sop("d1="+d1);  
         sop("l="+l);  
           
         double d2 = Math.pow(2,3); //pow(A,B):返回A的B次幂，返回2的3次幂。  
         sop("2的3次幂："+d2);  
     }  
       
     public static void sop(Object obj){  
         System.out.println(obj);  
     }  
 }  

Random类在java.util包中，Random类的nextInt(num)可以返回一个0到num之间的随机数，包括首不包括尾。

代码示例：

[java]view plaincopy 
   
 import java.util.*;  
 class RandomDemo{  
     public static void main(String[] args){  
         Random r = new Random();  
           
         for(int x=0; x<10; x++){  
             int d = r.nextInt(10)+1;  //nextInt(10):返回0和10之间的随机一个值，包括前不包括后。  
             sop(d);  
         }  
     }  
 }  