common-lang工具包

package toolsTest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;

import junit.framework.TestCase;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.CharSet;
import org.apache.commons.lang3.CharSetUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.SerializationUtils;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.commons.lang3.text.WordUtils;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.commons.lang3.time.StopWatch;
import org.junit.Test;

/**
 * common-lang工具包测试
 * @author Administrator
 *
 */
public class Tests extends TestCase {
    
    /**
     * 数组测试:
     * ArrayUtils.toString(Object array):将数组转换成字符串
     * ArrayUtils.toString(Object array,stringIfNull):将数组转换成字符串,如果这个字符串为空时以stringIfNull这个自定义字符串替代
     * ArrayUtils.contains(Object array, objectToFind):数组array中是否含有objectToFind,含有返回true,否则返回false
     * ArrayUtils.indexOf(Object array, objectToFind):数组array中第一次出现objectToFind的位置,有返回下标,没有返回-1
     * ArrayUtils.lastIndexOf(Object array, objectToFind):数组array中最后一个objectToFind的位置,有返回下标,没有返回-1
     * ArrayUtils.clone(Object array):克隆数组,如果是直接赋值的话,因为引用地址是一样的,一个数组改变也会影响另外的那个数组
     * ArrayUtils.toMap(Object array):将二维数组转换成Map
     */
    @SuppressWarnings("unchecked")
    @Test
    public void test(){
        int a[]=null;
        System.out.println(ArrayUtils.toString(a, "这个为空时的值"));//这个为空时的值
        String array1[]={"苹果","桔子"};
        System.out.println(array1);//[Ljava.lang.String;@6ee7e2ec
        System.out.println(ArrayUtils.toString(array1));//{苹果,桔子}
        
        String array2[][]={{"name","桔子"},{"age","25"}};
        System.out.println(array2);//[[Ljava.lang.String;@49ada86
        System.out.println(ArrayUtils.toString(array2));//{{name,桔子},{age,25}}
        
        int array3[]={1,2,3,4,5,6,7,8,9,0,7};
        System.out.println("array3中是否有7:"+ArrayUtils.contains(array3, 7));//array3中是否有7:true
        System.out.println("array3中7的位置:"+ArrayUtils.indexOf(array3, 7));//array3中7的位置:6
        System.out.println("array3中最后一个7的位置:"+ArrayUtils.lastIndexOf(array3, 7));//array3中最后一个7的位置:10
        
        int array4[]=array3;
        array4[0]=11;
        System.out.println(ArrayUtils.toString(array3));//{11,2,3,4,5,6,7,8,9,0,7};可以看出array4改变会影响array3,因为他们的引用地址一样
        System.out.println(ArrayUtils.toString(array4));//{11,2,3,4,5,6,7,8,9,0,7}
        array3[0]=1;
        int array5[]=ArrayUtils.clone(array3);
        array5[1]=22;
        System.out.println(ArrayUtils.toString(array3));//{1,2,3,4,5,6,7,8,9,0,7}
        System.out.println(ArrayUtils.toString(array5));//{1,22,3,4,5,6,7,8,9,0,7}
        
        ArrayUtils.reverse(array3);//反转数组
        System.out.println(ArrayUtils.toString(array3));//{7,0,9,8,7,6,5,4,3,2,1}
        
        int array6[]={1,2,3};
        Integer array7[]=ArrayUtils.toObject(array6);
        System.out.println(ArrayUtils.toString(array7));//{1,2,3}
        
        Map arrayToMap=ArrayUtils.toMap(array2);
        System.out.println(arrayToMap.get("name"));//桔子
    }
    
    /**
     * 字符串测试:
     * StringUtils.isBlank(String str):判断字符串是否为空字符串
     * StringUtils.isNumeric(String str);判断字符串是否是数字
     * StringUtils.chomp(String str):去除换行符
     * StringUtils.reverseDelimited(String str,char separatorChar):字符串str以separatorChar这个字符进行反转
     */
    @Test
    public void test2(){
        String str1 = "";
        String str2 = " ";
        String str3 = "\t";
        String str4 = null;
        String str5 = "123";
        String str6 = "ABCDEFG"; 
        String str7 = "It feels good to use Jakarta Commons.\r\n";
        System.out.println(StringUtils.isBlank(str1));//true
        System.out.println(StringUtils.isBlank(str2));//true
        System.out.println(StringUtils.isBlank(str3));//true
        System.out.println(StringUtils.isBlank(str4));//true
        System.out.println("Is str5 numeric? " + StringUtils.isNumeric(str5));//Is str5 numeric? true
        System.out.println("Is str6 numeric? " + StringUtils.isNumeric(str6));//Is str5 numeric? true
        System.out.println("str7: " + str7);//str7: It feels good to use Jakarta Commons.
        System.out.println("================================");
        String str8 = StringUtils.chomp(str7); 
        str8 = StringUtils.reverseDelimited(str8, ' ');
        System.out.println("str7 reversed whole words : \r\n" + str8);//str7 reversed whole words : Commons. Jakarta use to good feels It
        System.out.println("================================");
    }
    
    @Test
    public void test3(){
        CharSet charSet = CharSet.getInstance("aeiou");
        System.out.println(charSet.contains('a'));//true
        System.out.println(charSet.contains('n'));//false
    }
    
    /**
     * CharSetUtils测试:
     * CharSetUtils.count(String arg0, String... arg1):计算字符串arg0中包含arg1中某字符数
     * 注:String... arg1可变长参数
     * CharSetUtils.delete(String arg0, String... set):删除arg0字符串中某字符
     * CharSetUtils.keep(String arg0, String... set):保留arg0字符串中某字符
     * CharSetUtils.squeeze(String arg0,String... arg1):合并arg0中重复的字符
     * CharSetUtils.containsAny(String arg0,String... arg1):字符串中arg0只要包含arg1中某个字符就返回true,否则返回false
     * 
     */
    @Test
    public void test4(){
        System.out.println("计算字符串中包含某字符数.");  
        System.out.println(CharSetUtils.count("The quick brown fox jumps over the lazy dog.","a","e"));//4
        System.out.println(CharSetUtils.count("The quick brown fox jumps over the lazy dog.","ae"));//4
   
        System.out.println("删除字符串中某字符.");  
        System.out.println(CharSetUtils.delete("The quick brown fox jumps over the lazy dog.", "ae"));//Th quick brown fox jumps ovr th lzy dog.
   
        System.out.println("保留字符串中某字符.");  
        System.out.println(CharSetUtils.keep("The quick brown fox jumps over the lazy dog.", "ae"));//eeea
   
        System.out.println("合并重复的字符.");  
        System.out.println(CharSetUtils.squeeze("a  bbbbbb     c dd eeeeee", "b d","e"));//a b c d e
        System.out.println("字符串中只要包含某个字符就返回true,否则返回false");
        System.out.println( CharSetUtils.containsAny("abcde", "ahpoiu"));//true
    }
    /**
     * ObjectUtils测试:
     * ObjectUtils.defaultIfNull(Object object, Object defaultValue):如果object为空则返回defaultValue,不为空返回自身即object
     */
    @Test
    public void test5(){
         System.out.println("Object为null时，默认打印某字符.");  
         Object obj = null;
         System.out.println(ObjectUtils.defaultIfNull(obj, "空"));  //空
    }
    
    /**
     * SerializationUtils测试:
     * SerializationUtils.serialize(Serializable obj):序列化对象
     * SerializationUtils.deserialize(byte[] objectData):反序列化
     */
    @Test
    public void test6(){
         Date date = new Date();  
         byte[] bytes = SerializationUtils.serialize(date);  
         System.out.println(ArrayUtils.toString(bytes));  
         System.out.println(date);  
         
         Date reDate = (Date) SerializationUtils.deserialize(bytes);  
         System.out.println(reDate);  
         System.out.println(date.equals(reDate));//true
         System.out.println(date == reDate);  //false
         
         FileOutputStream fos = null;  
         FileInputStream fis = null;  
         try {  
             fos = new FileOutputStream(new File("d:/test.txt"));  
             fis = new FileInputStream(new File("d:/test.txt"));  
             SerializationUtils.serialize(date, fos);  
             Date reDate2 = (Date) SerializationUtils.deserialize(fis);  
    
             System.out.println(date.equals(reDate2));//true
    
         } catch (FileNotFoundException e) {  
             e.printStackTrace();  
         } finally {  
             try {  
                 fos.close();  
                 fis.close();  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
         
    }
    
    /**
     * RandomStringUtils测试:
     * RandomStringUtils.random(int count,String chars):在指定字符串中生成长度为n的随机字符串
     * RandomStringUtils.random(int count, boolean letters, boolean numbers):指定从字符或数字中生成随机字符串
     * letters:字母 ;numbers;数字
     */
    @Test
    public void test7(){
        System.out.println(RandomStringUtils.random(5,"abcdefghijk"));
        System.out.println(RandomStringUtils.random(5, true, false));  
        System.out.println(RandomStringUtils.random(5, false, true)); 
        System.out.println(RandomStringUtils.random(5, true, true)); 
    }
    
    /**
     * StringUtils测试:
     * StringUtils.repeat(String arg0,int arg1):将字符串arg0重复arg1次
     * StringUtils.center(String str, int size, String padStr):将字符串str按某size居中,长度不足以padStr填充
     * StringUtils.join(Object[] array, String separator):将字符串数组array用字符串separator连接
     * StringUtils.abbreviate(String str, int maxWidth):缩短到某长度,用...结尾
     * StringUtils.abbreviate(String str,int offset,int maxWidth):缩短到某长度,用...结尾
     * StringUtils.indexOfDifference(CharSequence cs1, CharSequence cs2):返回两字符串第一次不同处索引号(从0开始)
     * StringUtils.difference(String str1,String str2):返回两字符串不同处开始至结束
     * StringUtils.containsOnly(CharSequence cs, String validChars):检查一字符串是否为另一字符串的子集
     * StringUtils.containsNone(CharSequence cs, String validChars):检查一字符串是否不是另一字符串的子集
     * StringUtils.contains(CharSequence seq, CharSequence searchSeq):检查一字符串是否包含另一字符串
     * StringUtils.defaultString(String str, String defaultStr):如果str为null时返回defaultStr
     * StringUtils.split(String str, String separatorChars):将str字符串以separatorChars分割成数组
     * StringUtils.deleteWhitespace(String arg0):去除字符中的空格
     * StringUtils.isAlpha(CharSequence arg0):判断arg0是否全是字母和汉字
     * StringUtils.isNumeric(CharSequence arg0):判断arg0是否全是数字
     * StringUtils.isAlphanumeric(CharSequence arg0):判断arg0是否全是数字和数字和汉字
     * StringUtils.isBlank(CharSequence arg0):判断arg0是否为空
     */
    @Test
    public void test8(){
        System.out.println("将字符串重复n次，将文字按某宽度居中，将字符串数组用某字符串连接.");  
        String[] header = new String[3];  
        header[0] = StringUtils.repeat("*", 50);  
        header[1] = StringUtils.center("  StringUtilsDemo  ", 50, "^O^");  
        header[2] = header[0];  
        String head = StringUtils.join(header, "\n");  
        System.out.println(head);  
        
        System.out.println("缩短到某长度,用...结尾.");  
        System.out.println(StringUtils.abbreviate("The quick brown fox jumps over the lazy dog.", 10));//The quick...
        System.out.println(StringUtils.abbreviate("The quick brown fox jumps over the lazy dog.", 15, 10));//... fox...
        
        System.out.println("返回两字符串不同处索引号.");  
        System.out.println(StringUtils.indexOfDifference("aaabc", "aaacc"));//3
        
        System.out.println("返回两字符串不同处开始至结束.");  
        System.out.println(StringUtils.difference("aaabcde", "aaaccde"));  //ccde
        
        System.out.println("检查一字符串是否为另一字符串的子集.");  
        System.out.println(StringUtils.containsOnly("aad", "aadd"));  //true
        
        System.out.println("检查一字符串是否不是另一字符串的子集.");  
        System.out.println(StringUtils.containsNone("defg", "aadd")); //true
        
        System.out.println("检查一字符串是否包含另一字符串.");  
        System.out.println(StringUtils.contains("defg", "ef"));  //true
        
        System.out.println("返回可以处理null的toString().");  
        System.out.println(StringUtils.defaultString(null, "空"));  //空
        
        System.out.println("去除字符中的空格.");  
        System.out.println(StringUtils.deleteWhitespace(" aa  bb  cc "));  //aabbcc
        
        System.out.println("分隔符处理成数组.");  
        String[] strArray = StringUtils.split("a,b,,c,d,null,e", ",");  
        System.out.println(ArrayUtils.toString(strArray));  //{a,b,c,d,null,e}
        
        System.out.println("判断是否是某类字符.");  
        System.out.println(StringUtils.isAlpha("ab"));  //true
        System.out.println(StringUtils.isAlphanumeric("12aa")); //true 
        System.out.println(StringUtils.isBlank(""));  //true
        System.out.println(StringUtils.isNumeric("123"));  //true
    }
    
    /**
     * SystemUtils测试:
     * SystemUtils.FILE_SEPARATOR:获得系统文件分隔符
     */
     @Test
     public void test9(){
        System.out.println("获得系统文件分隔符.");  
        System.out.println(SystemUtils.FILE_SEPARATOR);  
        
        System.out.println("获得源文件编码.");  
        System.out.println(SystemUtils.FILE_ENCODING); 
        
        System.out.println("获得ext目录.");  
        System.out.println(SystemUtils.JAVA_EXT_DIRS);  
   
        System.out.println("获得java版本.");  
        System.out.println(SystemUtils.JAVA_VM_VERSION);  
   
        System.out.println("获得java厂商.");  
        System.out.println(SystemUtils.JAVA_VENDOR); 
     }
     
     @Test
     public void test10(){
        System.out.println("转换特殊字符.");  
        System.out.println("html:" + StringEscapeUtils.escapeHtml3("<"));//html:&lt;
        System.out.println("html:" + StringEscapeUtils.escapeHtml4(">"));//html:&gt;
        System.out.println("html:" + StringEscapeUtils.unescapeHtml3("<p>"));//html:<p>
        System.out.println("html:" + StringEscapeUtils.unescapeHtml4("<p>"));//html:<p>
     }
     
     /**
      * NumberUtils测试:
      * NumberUtils.toInt(String arg0, int arg1):字符串arg0转换成数字,转换失败择返回arg1
      * NumberUtils.max(int...arg0):从数组中选出最大值
      * NumberUtils.isDigits(String arg0):判断字符串是否全是整数
      * NumberUtils.isNumber(String arg0):判断字符串是否是有效数字
      * 
      */
     @Test
     public void test11(){
         System.out.println("字符串转为数字");  
         System.out.println(NumberUtils.toInt("33", 0));//33
         
         System.out.println("从数组中选出最大值.");  
         System.out.println(NumberUtils.max(new int[] {1, 2, 3, 4 }));
         System.out.println("判断字符串是否全是整数.");  
         System.out.println(NumberUtils.isDigits("123.1"));  

         System.out.println("判断字符串是否是有效数字.");  
         System.out.println(NumberUtils.isNumber("0123.1"));
     }
     
     @SuppressWarnings("unchecked")
     @Test
     public void test12(){
        System.out.println("格式化日期输出.");  
        System.out.println(DateFormatUtils.format(System.currentTimeMillis(), "yyyy-MM-dd HH:mm:ss"));  
   
        System.out.println("秒表.");  
        StopWatch sw = new StopWatch();  
        sw.start();  
   
        for (Iterator iterator = DateUtils.iterator(new Date(), DateUtils.RANGE_WEEK_CENTER); iterator.hasNext();) {  
            Calendar cal = (Calendar) iterator.next();  
            System.out.println(DateFormatUtils.format(cal.getTime(), "yyyy-MM-dd HH:mm:ss"));  
        }  
   
        sw.stop();  
        System.out.println("秒表计时:" + sw.getTime());  
     }
     
     @Test
     public void test13(){
         String[] strarray = { "a", "b", "c" };  
         System.out.println("验证功能");  
         System.out.println(Validate.notEmpty(strarray));  
     }
     
     @Test
     public void test14(){
         System.out.println("单词处理功能");  
         String str1 = "wOrD";  
         String str2 = "ghj\nui\tpo";  
         System.out.println(WordUtils.capitalize(str1)); // 首字母大写  
         System.out.println(WordUtils.capitalizeFully(str1)); // 首字母大写其它字母小写  
         char[] ctrg = { '.' };  
         System.out.println(WordUtils.capitalizeFully("i aM.fine", ctrg)); // 在规则地方转换  
         System.out.println(WordUtils.initials(str1)); // 获取首字母  
         System.out.println(WordUtils.initials("Ben John Lee", null)); // 取每个单词的首字母  
         char[] ctr = { ' ', '.' };  
         System.out.println(WordUtils.initials("Ben J.Lee", ctr)); // 按指定规则获取首字母  
         System.out.println(WordUtils.swapCase(str1)); // 大小写逆转  
         System.out.println(WordUtils.wrap(str2, 1)); // 解析\n和\t等字符  
     } 
}