• java常用工具类（一）

    一、String工具类

    1. package com.mkyong.common;  
    2.    
    3. import java.util.ArrayList;  
    4. import java.util.List;  
    5.    
    6. /** 
    7.  *  
    8.  * String工具类. <br> 
    9.  *  
    10.  * @author 宋立君 
    11.  * @date 2014年06月24日 
    12.  */  
    13. public class StringUtil {  
    14.    
    15.     private static final int INDEX_NOT_FOUND = -1;  
    16.     private static final String EMPTY = "";  
    17.     /** 
    18.      * <p> 
    19.      * The maximum size to which the padding constant(s) can expand. 
    20.      * </p> 
    21.      */  
    22.     private static final int PAD_LIMIT = 8192;  
    23.    
    24.     /** 
    25.      * 功能：将半角的符号转换成全角符号.(即英文字符转中文字符) 
    26.      *  
    27.      * @author 宋立君 
    28.      * @param str 
    29.      *            源字符串 
    30.      * @return String 
    31.      * @date 2014年06月24日 
    32.      */  
    33.     public static String changeToFull(String str) {  
    34.         String source = "1234567890!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_=+\|[];:'",<.>/?";  
    35.         String[] decode = { "１", "２", "３", "４", "５", "６", "７", "８", "９", "０",  
    36.                 "！", "＠", "＃", "＄", "％", "︿", "＆", "＊", "（", "）", "ａ", "ｂ",  
    37.                 "ｃ", "ｄ", "ｅ", "ｆ", "ｇ", "ｈ", "ｉ", "ｊ", "ｋ", "ｌ", "ｍ", "ｎ",  
    38.                 "ｏ", "ｐ", "ｑ", "ｒ", "ｓ", "ｔ", "ｕ", "ｖ", "ｗ", "ｘ", "ｙ", "ｚ",  
    39.                 "Ａ", "Ｂ", "Ｃ", "Ｄ", "Ｅ", "Ｆ", "Ｇ", "Ｈ", "Ｉ", "Ｊ", "Ｋ", "Ｌ",  
    40.                 "Ｍ", "Ｎ", "Ｏ", "Ｐ", "Ｑ", "Ｒ", "Ｓ", "Ｔ", "Ｕ", "Ｖ", "Ｗ", "Ｘ",  
    41.                 "Ｙ", "Ｚ", "－", "＿", "＝", "＋", "＼", "｜", "【", "】", "；", "：",  
    42.                 "'", """, "，", "〈", "。", "〉", "／", "？" };  
    43.         String result = "";  
    44.         for (int i = 0; i < str.length(); i++) {  
    45.             int pos = source.indexOf(str.charAt(i));  
    46.             if (pos != -1) {  
    47.                 result += decode[pos];  
    48.             } else {  
    49.                 result += str.charAt(i);  
    50.             }  
    51.         }  
    52.         return result;  
    53.     }  
    54.    
    55.     /** 
    56.      * 功能：cs串中是否一个都不包含字符数组searchChars中的字符。 
    57.      *  
    58.      * @author 宋立君 
    59.      * @param cs 
    60.      *            字符串 
    61.      * @param searchChars 
    62.      *            字符数组 
    63.      * @return boolean 都不包含返回true，否则返回false。 
    64.      * @date 2014年06月24日 
    65.      */  
    66.     public static boolean containsNone(CharSequence cs, char... searchChars) {  
    67.         if (cs == null || searchChars == null) {  
    68.             return true;  
    69.         }  
    70.         int csLen = cs.length();  
    71.         int csLast = csLen - 1;  
    72.         int searchLen = searchChars.length;  
    73.         int searchLast = searchLen - 1;  
    74.         for (int i = 0; i < csLen; i++) {  
    75.             char ch = cs.charAt(i);  
    76.             for (int j = 0; j < searchLen; j++) {  
    77.                 if (searchChars[j] == ch) {  
    78.                     if (Character.isHighSurrogate(ch)) {  
    79.                         if (j == searchLast) {  
    80.                             // missing low surrogate, fine, like  
    81.                             // String.indexOf(String)  
    82.                             return false;  
    83.                         }  
    84.                         if (i < csLast  
    85.                                 && searchChars[j + 1] == cs.charAt(i + 1)) {  
    86.                             return false;  
    87.                         }  
    88.                     } else {  
    89.                         // ch is in the Basic Multilingual Plane  
    90.                         return false;  
    91.                     }  
    92.                 }  
    93.             }  
    94.         }  
    95.         return true;  
    96.     }  
    97.    
    98.     /** 
    99.      * <p> 
    100.      * 编码为Unicode，格式 'u0020'. 
    101.      * </p> 
    102.      *  
    103.      * @author 宋立君 
    104.      *  
    105.      *         <pre> 
    106.      *   CharUtils.unicodeEscaped(' ') = "u0020" 
    107.      *   CharUtils.unicodeEscaped('A') = "u0041" 
    108.      * </pre> 
    109.      *  
    110.      * @param ch 
    111.      *            源字符串 
    112.      * @return 转码后的字符串 
    113.      * @date 2014年06月24日 
    114.      */  
    115.     public static String unicodeEscaped(char ch) {  
    116.         if (ch < 0x10) {  
    117.             return "\u000" + Integer.toHexString(ch);  
    118.         } else if (ch < 0x100) {  
    119.             return "\u00" + Integer.toHexString(ch);  
    120.         } else if (ch < 0x1000) {  
    121.             return "\u0" + Integer.toHexString(ch);  
    122.         }  
    123.         return "\u" + Integer.toHexString(ch);  
    124.     }  
    125.    
    126.     /** 
    127.      * <p> 
    128.      * 进行tostring操作，如果传入的是null，返回空字符串。 
    129.      * </p> 
    130.      * 
    131.      * <pre> 
    132.      * ObjectUtils.toString(null)         = "" 
    133.      * ObjectUtils.toString("")           = "" 
    134.      * ObjectUtils.toString("bat")        = "bat" 
    135.      * ObjectUtils.toString(Boolean.TRUE) = "true" 
    136.      * </pre> 
    137.      * 
    138.      * @param obj 
    139.      *            源 
    140.      * @return String 
    141.      */  
    142.     public static String toString(Object obj) {  
    143.         return obj == null ? "" : obj.toString();  
    144.     }  
    145.    
    146.     /** 
    147.      * <p> 
    148.      * 进行tostring操作，如果传入的是null，返回指定的默认值。 
    149.      * </p> 
    150.      * 
    151.      * <pre> 
    152.      * ObjectUtils.toString(null, null)           = null 
    153.      * ObjectUtils.toString(null, "null")         = "null" 
    154.      * ObjectUtils.toString("", "null")           = "" 
    155.      * ObjectUtils.toString("bat", "null")        = "bat" 
    156.      * ObjectUtils.toString(Boolean.TRUE, "null") = "true" 
    157.      * </pre> 
    158.      * 
    159.      * @param obj 
    160.      *            源 
    161.      * @param nullStr 
    162.      *            如果obj为null时返回这个指定值 
    163.      * @return String 
    164.      */  
    165.     public static String toString(Object obj, String nullStr) {  
    166.         return obj == null ? nullStr : obj.toString();  
    167.     }  
    168.    
    169.     /** 
    170.      * <p> 
    171.      * 只从源字符串中移除指定开头子字符串. 
    172.      * </p> 
    173.      *  
    174.      * <pre> 
    175.      * StringUtil.removeStart(null, *)      = null 
    176.      * StringUtil.removeStart("", *)        = "" 
    177.      * StringUtil.removeStart(*, null)      = * 
    178.      * StringUtil.removeStart("www.domain.com", "www.")   = "domain.com" 
    179.      * StringUtil.removeStart("domain.com", "www.")       = "domain.com" 
    180.      * StringUtil.removeStart("www.domain.com", "domain") = "www.domain.com" 
    181.      * StringUtil.removeStart("abc", "")    = "abc" 
    182.      * </pre> 
    183.      * 
    184.      * @param str 
    185.      *            源字符串 
    186.      * @param remove 
    187.      *            将要被移除的子字符串 
    188.      * @return String 
    189.      */  
    190.     public static String removeStart(String str, String remove) {  
    191.         if (isEmpty(str) || isEmpty(remove)) {  
    192.             return str;  
    193.         }  
    194.         if (str.startsWith(remove)) {  
    195.             return str.substring(remove.length());  
    196.         }  
    197.         return str;  
    198.     }  
    199.    
    200.     /** 
    201.      * <p> 
    202.      * 只从源字符串中移除指定结尾的子字符串. 
    203.      * </p> 
    204.      *  
    205.      * <pre> 
    206.      * StringUtil.removeEnd(null, *)      = null 
    207.      * StringUtil.removeEnd("", *)        = "" 
    208.      * StringUtil.removeEnd(*, null)      = * 
    209.      * StringUtil.removeEnd("www.domain.com", ".com.")  = "www.domain.com" 
    210.      * StringUtil.removeEnd("www.domain.com", ".com")   = "www.domain" 
    211.      * StringUtil.removeEnd("www.domain.com", "domain") = "www.domain.com" 
    212.      * StringUtil.removeEnd("abc", "")    = "abc" 
    213.      * </pre> 
    214.      * 
    215.      * @param str 
    216.      *            源字符串 
    217.      * @param remove 
    218.      *            将要被移除的子字符串 
    219.      * @return String 
    220.      */  
    221.     public static String removeEnd(String str, String remove) {  
    222.         if (isEmpty(str) || isEmpty(remove)) {  
    223.             return str;  
    224.         }  
    225.         if (str.endsWith(remove)) {  
    226.             return str.substring(0, str.length() - remove.length());  
    227.         }  
    228.         return str;  
    229.     }  
    230.    
    231.     /** 
    232.      * <p> 
    233.      * 将一个字符串重复N次 
    234.      * </p> 
    235.      * 
    236.      * <pre> 
    237.      * StringUtil.repeat(null, 2) = null 
    238.      * StringUtil.repeat("", 0)   = "" 
    239.      * StringUtil.repeat("", 2)   = "" 
    240.      * StringUtil.repeat("a", 3)  = "aaa" 
    241.      * StringUtil.repeat("ab", 2) = "abab" 
    242.      * StringUtil.repeat("a", -2) = "" 
    243.      * </pre> 
    244.      * 
    245.      * @param str 
    246.      *            源字符串 
    247.      * @param repeat 
    248.      *            重复的次数 
    249.      * @return String 
    250.      */  
    251.     public static String repeat(String str, int repeat) {  
    252.         // Performance tuned for 2.0 (JDK1.4)  
    253.    
    254.         if (str == null) {  
    255.             return null;  
    256.         }  
    257.         if (repeat <= 0) {  
    258.             return EMPTY;  
    259.         }  
    260.         int inputLength = str.length();  
    261.         if (repeat == 1 || inputLength == 0) {  
    262.             return str;  
    263.         }  
    264.         if (inputLength == 1 && repeat <= PAD_LIMIT) {  
    265.             return repeat(str.charAt(0), repeat);  
    266.         }  
    267.    
    268.         int outputLength = inputLength * repeat;  
    269.         switch (inputLength) {  
    270.         case 1:  
    271.             return repeat(str.charAt(0), repeat);  
    272.         case 2:  
    273.             char ch0 = str.charAt(0);  
    274.             char ch1 = str.charAt(1);  
    275.             char[] output2 = new char[outputLength];  
    276.             for (int i = repeat * 2 - 2; i >= 0; i--, i--) {  
    277.                 output2[i] = ch0;  
    278.                 output2[i + 1] = ch1;  
    279.             }  
    280.             return new String(output2);  
    281.         default:  
    282.             StringBuilder buf = new StringBuilder(outputLength);  
    283.             for (int i = 0; i < repeat; i++) {  
    284.                 buf.append(str);  
    285.             }  
    286.             return buf.toString();  
    287.         }  
    288.     }  
    289.    
    290.     /** 
    291.      * <p> 
    292.      * 将一个字符串重复N次，并且中间加上指定的分隔符 
    293.      * </p> 
    294.      * 
    295.      * <pre> 
    296.      * StringUtil.repeat(null, null, 2) = null 
    297.      * StringUtil.repeat(null, "x", 2)  = null 
    298.      * StringUtil.repeat("", null, 0)   = "" 
    299.      * StringUtil.repeat("", "", 2)     = "" 
    300.      * StringUtil.repeat("", "x", 3)    = "xxx" 
    301.      * StringUtil.repeat("?", ", ", 3)  = "?, ?, ?" 
    302.      * </pre> 
    303.      * 
    304.      * @param str 
    305.      *            源字符串 
    306.      * @param separator 
    307.      *            分隔符 
    308.      * @param repeat 
    309.      *            重复次数 
    310.      * @return String 
    311.      */  
    312.     public static String repeat(String str, String separator, int repeat) {  
    313.         if (str == null || separator == null) {  
    314.             return repeat(str, repeat);  
    315.         } else {  
    316.             // given that repeat(String, int) is quite optimized, better to rely  
    317.             // on it than try and splice this into it  
    318.             String result = repeat(str + separator, repeat);  
    319.             return removeEnd(result, separator);  
    320.         }  
    321.     }  
    322.    
    323.     /** 
    324.      * <p> 
    325.      * 将某个字符重复N次. 
    326.      * </p> 
    327.      * 
    328.      * @param ch 
    329.      *            某个字符 
    330.      * @param repeat 
    331.      *            重复次数 
    332.      * @return String 
    333.      */  
    334.     public static String repeat(char ch, int repeat) {  
    335.         char[] buf = new char[repeat];  
    336.         for (int i = repeat - 1; i >= 0; i--) {  
    337.             buf[i] = ch;  
    338.         }  
    339.         return new String(buf);  
    340.     }  
    341.    
    342.     /** 
    343.      * <p> 
    344.      * 字符串长度达不到指定长度时，在字符串右边补指定的字符. 
    345.      * </p> 
    346.      *  
    347.      * <pre> 
    348.      * StringUtil.rightPad(null, *, *)     = null 
    349.      * StringUtil.rightPad("", 3, 'z')     = "zzz" 
    350.      * StringUtil.rightPad("bat", 3, 'z')  = "bat" 
    351.      * StringUtil.rightPad("bat", 5, 'z')  = "batzz" 
    352.      * StringUtil.rightPad("bat", 1, 'z')  = "bat" 
    353.      * StringUtil.rightPad("bat", -1, 'z') = "bat" 
    354.      * </pre> 
    355.      * 
    356.      * @param str 
    357.      *            源字符串 
    358.      * @param size 
    359.      *            指定的长度 
    360.      * @param padChar 
    361.      *            进行补充的字符 
    362.      * @return String 
    363.      */  
    364.     public static String rightPad(String str, int size, char padChar) {  
    365.         if (str == null) {  
    366.             return null;  
    367.         }  
    368.         int pads = size - str.length();  
    369.         if (pads <= 0) {  
    370.             return str; // returns original String when possible  
    371.         }  
    372.         if (pads > PAD_LIMIT) {  
    373.             return rightPad(str, size, String.valueOf(padChar));  
    374.         }  
    375.         return str.concat(repeat(padChar, pads));  
    376.     }  
    377.    
    378.     /** 
    379.      * <p> 
    380.      * 扩大字符串长度，从左边补充指定字符 
    381.      * </p> 
    382.      *  
    383.      * <pre> 
    384.      * StringUtil.rightPad(null, *, *)      = null 
    385.      * StringUtil.rightPad("", 3, "z")      = "zzz" 
    386.      * StringUtil.rightPad("bat", 3, "yz")  = "bat" 
    387.      * StringUtil.rightPad("bat", 5, "yz")  = "batyz" 
    388.      * StringUtil.rightPad("bat", 8, "yz")  = "batyzyzy" 
    389.      * StringUtil.rightPad("bat", 1, "yz")  = "bat" 
    390.      * StringUtil.rightPad("bat", -1, "yz") = "bat" 
    391.      * StringUtil.rightPad("bat", 5, null)  = "bat  " 
    392.      * StringUtil.rightPad("bat", 5, "")    = "bat  " 
    393.      * </pre> 
    394.      * 
    395.      * @param str 
    396.      *            源字符串 
    397.      * @param size 
    398.      *            扩大后的长度 
    399.      * @param padStr 
    400.      *            在右边补充的字符串 
    401.      * @return String 
    402.      */  
    403.     public static String rightPad(String str, int size, String padStr) {  
    404.         if (str == null) {  
    405.             return null;  
    406.         }  
    407.         if (isEmpty(padStr)) {  
    408.             padStr = " ";  
    409.         }  
    410.         int padLen = padStr.length();  
    411.         int strLen = str.length();  
    412.         int pads = size - strLen;  
    413.         if (pads <= 0) {  
    414.             return str; // returns original String when possible  
    415.         }  
    416.         if (padLen == 1 && pads <= PAD_LIMIT) {  
    417.             return rightPad(str, size, padStr.charAt(0));  
    418.         }  
    419.    
    420.         if (pads == padLen) {  
    421.             return str.concat(padStr);  
    422.         } else if (pads < padLen) {  
    423.             return str.concat(padStr.substring(0, pads));  
    424.         } else {  
    425.             char[] padding = new char[pads];  
    426.             char[] padChars = padStr.toCharArray();  
    427.             for (int i = 0; i < pads; i++) {  
    428.                 padding[i] = padChars[i % padLen];  
    429.             }  
    430.             return str.concat(new String(padding));  
    431.         }  
    432.     }  
    433.    
    434.     /** 
    435.      * <p> 
    436.      * 扩大字符串长度，从左边补充空格 
    437.      * </p> 
    438.      * 
    439.      * <pre> 
    440.      * StringUtil.leftPad(null, *)   = null 
    441.      * StringUtil.leftPad("", 3)     = "   " 
    442.      * StringUtil.leftPad("bat", 3)  = "bat" 
    443.      * StringUtil.leftPad("bat", 5)  = "  bat" 
    444.      * StringUtil.leftPad("bat", 1)  = "bat" 
    445.      * StringUtil.leftPad("bat", -1) = "bat" 
    446.      * </pre> 
    447.      * 
    448.      * @param str 
    449.      *            源字符串 
    450.      * @param size 
    451.      *            扩大后的长度 
    452.      * @return String 
    453.      */  
    454.     public static String leftPad(String str, int size) {  
    455.         return leftPad(str, size, ' ');  
    456.     }  
    457.    
    458.     /** 
    459.      * <p> 
    460.      * 扩大字符串长度，从左边补充指定的字符 
    461.      * </p> 
    462.      * 
    463.      * <pre> 
    464.      * StringUtil.leftPad(null, *, *)     = null 
    465.      * StringUtil.leftPad("", 3, 'z')     = "zzz" 
    466.      * StringUtil.leftPad("bat", 3, 'z')  = "bat" 
    467.      * StringUtil.leftPad("bat", 5, 'z')  = "zzbat" 
    468.      * StringUtil.leftPad("bat", 1, 'z')  = "bat" 
    469.      * StringUtil.leftPad("bat", -1, 'z') = "bat" 
    470.      * </pre> 
    471.      * 
    472.      * @param str 
    473.      *            源字符串 
    474.      * @param size 
    475.      *            扩大后的长度 
    476.      * @param padStr 
    477.      *            补充的字符 
    478.      * @return String 
    479.      */  
    480.     public static String leftPad(String str, int size, char padChar) {  
    481.         if (str == null) {  
    482.             return null;  
    483.         }  
    484.         int pads = size - str.length();  
    485.         if (pads <= 0) {  
    486.             return str; // returns original String when possible  
    487.         }  
    488.         if (pads > PAD_LIMIT) {  
    489.             return leftPad(str, size, String.valueOf(padChar));  
    490.         }  
    491.         return repeat(padChar, pads).concat(str);  
    492.     }  
    493.    
    494.     /** 
    495.      * <p> 
    496.      * 扩大字符串长度，从左边补充指定的字符 
    497.      * </p> 
    498.      *  
    499.      * <pre> 
    500.      * StringUtil.leftPad(null, *, *)      = null 
    501.      * StringUtil.leftPad("", 3, "z")      = "zzz" 
    502.      * StringUtil.leftPad("bat", 3, "yz")  = "bat" 
    503.      * StringUtil.leftPad("bat", 5, "yz")  = "yzbat" 
    504.      * StringUtil.leftPad("bat", 8, "yz")  = "yzyzybat" 
    505.      * StringUtil.leftPad("bat", 1, "yz")  = "bat" 
    506.      * StringUtil.leftPad("bat", -1, "yz") = "bat" 
    507.      * StringUtil.leftPad("bat", 5, null)  = "  bat" 
    508.      * StringUtil.leftPad("bat", 5, "")    = "  bat" 
    509.      * </pre> 
    510.      * 
    511.      * @param str 
    512.      *            源字符串 
    513.      * @param size 
    514.      *            扩大后的长度 
    515.      * @param padStr 
    516.      *            补充的字符串 
    517.      * @return String 
    518.      */  
    519.     public static String leftPad(String str, int size, String padStr) {  
    520.         if (str == null) {  
    521.             return null;  
    522.         }  
    523.         if (isEmpty(padStr)) {  
    524.             padStr = " ";  
    525.         }  
    526.         int padLen = padStr.length();  
    527.         int strLen = str.length();  
    528.         int pads = size - strLen;  
    529.         if (pads <= 0) {  
    530.             return str; // returns original String when possible  
    531.         }  
    532.         if (padLen == 1 && pads <= PAD_LIMIT) {  
    533.             return leftPad(str, size, padStr.charAt(0));  
    534.         }  
    535.    
    536.         if (pads == padLen) {  
    537.             return padStr.concat(str);  
    538.         } else if (pads < padLen) {  
    539.             return padStr.substring(0, pads).concat(str);  
    540.         } else {  
    541.             char[] padding = new char[pads];  
    542.             char[] padChars = padStr.toCharArray();  
    543.             for (int i = 0; i < pads; i++) {  
    544.                 padding[i] = padChars[i % padLen];  
    545.             }  
    546.             return new String(padding).concat(str);  
    547.         }  
    548.     }  
    549.    
    550.     /** 
    551.      * <p> 
    552.      * 扩大字符串长度并将现在的字符串居中，被扩大部分用空格填充。 
    553.      * <p> 
    554.      *  
    555.      * <pre> 
    556.      * StringUtil.center(null, *)   = null 
    557.      * StringUtil.center("", 4)     = "    " 
    558.      * StringUtil.center("ab", -1)  = "ab" 
    559.      * StringUtil.center("ab", 4)   = " ab " 
    560.      * StringUtil.center("abcd", 2) = "abcd" 
    561.      * StringUtil.center("a", 4)    = " a  " 
    562.      * </pre> 
    563.      * 
    564.      * @param str 
    565.      *            源字符串 
    566.      * @param size 
    567.      *            扩大后的长度 
    568.      * @return String 
    569.      */  
    570.     public static String center(String str, int size) {  
    571.         return center(str, size, ' ');  
    572.     }  
    573.    
    574.     /** 
    575.      * <p> 
    576.      * 将字符串长度修改为指定长度，并进行居中显示。 
    577.      * </p> 
    578.      * 
    579.      * <pre> 
    580.      * StringUtil.center(null, *, *)     = null 
    581.      * StringUtil.center("", 4, ' ')     = "    " 
    582.      * StringUtil.center("ab", -1, ' ')  = "ab" 
    583.      * StringUtil.center("ab", 4, ' ')   = " ab" 
    584.      * StringUtil.center("abcd", 2, ' ') = "abcd" 
    585.      * StringUtil.center("a", 4, ' ')    = " a  " 
    586.      * StringUtil.center("a", 4, 'y')    = "yayy" 
    587.      * </pre> 
    588.      * 
    589.      * @param str 
    590.      *            源字符串 
    591.      * @param size 
    592.      *            指定的长度 
    593.      * @param padStr 
    594.      *            长度不够时补充的字符串 
    595.      * @return String 
    596.      * @throws IllegalArgumentException 
    597.      *             如果被补充字符串为 null或者 empty 
    598.      */  
    599.     public static String center(String str, int size, char padChar) {  
    600.         if (str == null || size <= 0) {  
    601.             return str;  
    602.         }  
    603.         int strLen = str.length();  
    604.         int pads = size - strLen;  
    605.         if (pads <= 0) {  
    606.             return str;  
    607.         }  
    608.         str = leftPad(str, strLen + pads / 2, padChar);  
    609.         str = rightPad(str, size, padChar);  
    610.         return str;  
    611.     }  
    612.    
    613.     /** 
    614.      * <p> 
    615.      * 将字符串长度修改为指定长度，并进行居中显示。 
    616.      * </p> 
    617.      * 
    618.      * <pre> 
    619.      * StringUtil.center(null, *, *)     = null 
    620.      * StringUtil.center("", 4, " ")     = "    " 
    621.      * StringUtil.center("ab", -1, " ")  = "ab" 
    622.      * StringUtil.center("ab", 4, " ")   = " ab" 
    623.      * StringUtil.center("abcd", 2, " ") = "abcd" 
    624.      * StringUtil.center("a", 4, " ")    = " a  " 
    625.      * StringUtil.center("a", 4, "yz")   = "yayz" 
    626.      * StringUtil.center("abc", 7, null) = "  abc  " 
    627.      * StringUtil.center("abc", 7, "")   = "  abc  " 
    628.      * </pre> 
    629.      * 
    630.      * @param str 
    631.      *            源字符串 
    632.      * @param size 
    633.      *            指定的长度 
    634.      * @param padStr 
    635.      *            长度不够时补充的字符串 
    636.      * @return String 
    637.      * @throws IllegalArgumentException 
    638.      *             如果被补充字符串为 null或者 empty 
    639.      */  
    640.     public static String center(String str, int size, String padStr) {  
    641.         if (str == null || size <= 0) {  
    642.             return str;  
    643.         }  
    644.         if (isEmpty(padStr)) {  
    645.             padStr = " ";  
    646.         }  
    647.         int strLen = str.length();  
    648.         int pads = size - strLen;  
    649.         if (pads <= 0) {  
    650.             return str;  
    651.         }  
    652.         str = leftPad(str, strLen + pads / 2, padStr);  
    653.         str = rightPad(str, size, padStr);  
    654.         return str;  
    655.     }  
    656.    
    657.     /** 
    658.      * <p> 
    659.      * 检查字符串是否全部为小写. 
    660.      * </p> 
    661.      *  
    662.      * <pre> 
    663.      * StringUtil.isAllLowerCase(null)   = false 
    664.      * StringUtil.isAllLowerCase("")     = false 
    665.      * StringUtil.isAllLowerCase("  ")   = false 
    666.      * StringUtil.isAllLowerCase("abc")  = true 
    667.      * StringUtil.isAllLowerCase("abC") = false 
    668.      * </pre> 
    669.      * 
    670.      * @param cs 
    671.      *            源字符串 
    672.      * @return String 
    673.      */  
    674.     public static boolean isAllLowerCase(String cs) {  
    675.         if (cs == null || isEmpty(cs)) {  
    676.             return false;  
    677.         }  
    678.         int sz = cs.length();  
    679.         for (int i = 0; i < sz; i++) {  
    680.             if (Character.isLowerCase(cs.charAt(i)) == false) {  
    681.                 return false;  
    682.             }  
    683.         }  
    684.         return true;  
    685.     }  
    686.    
    687.     /** 
    688.      * <p> 
    689.      * 检查是否都是大写. 
    690.      * </p> 
    691.      *  
    692.      * <pre> 
    693.      * StringUtil.isAllUpperCase(null)   = false 
    694.      * StringUtil.isAllUpperCase("")     = false 
    695.      * StringUtil.isAllUpperCase("  ")   = false 
    696.      * StringUtil.isAllUpperCase("ABC")  = true 
    697.      * StringUtil.isAllUpperCase("aBC") = false 
    698.      * </pre> 
    699.      * 
    700.      * @param cs 
    701.      *            源字符串 
    702.      * @return String 
    703.      */  
    704.     public static boolean isAllUpperCase(String cs) {  
    705.         if (cs == null || StringUtil.isEmpty(cs)) {  
    706.             return false;  
    707.         }  
    708.         int sz = cs.length();  
    709.         for (int i = 0; i < sz; i++) {  
    710.             if (Character.isUpperCase(cs.charAt(i)) == false) {  
    711.                 return false;  
    712.             }  
    713.         }  
    714.         return true;  
    715.     }  
    716.    
    717.     /** 
    718.      * <p> 
    719.      * 反转字符串. 
    720.      * </p> 
    721.      *  
    722.      * <pre> 
    723.      * StringUtil.reverse(null)  = null 
    724.      * StringUtil.reverse("")    = "" 
    725.      * StringUtil.reverse("bat") = "tab" 
    726.      * </pre> 
    727.      * 
    728.      * @param str 
    729.      *            源字符串 
    730.      * @return String 
    731.      */  
    732.     public static String reverse(String str) {  
    733.         if (str == null) {  
    734.             return null;  
    735.         }  
    736.         return new StringBuilder(str).reverse().toString();  
    737.     }  
    738.    
    739.     /** 
    740.      * <p> 
    741.      * 字符串达不到一定长度时在右边补空白. 
    742.      * </p> 
    743.      *  
    744.      * <pre> 
    745.      * StringUtil.rightPad(null, *)   = null 
    746.      * StringUtil.rightPad("", 3)     = "   " 
    747.      * StringUtil.rightPad("bat", 3)  = "bat" 
    748.      * StringUtil.rightPad("bat", 5)  = "bat  " 
    749.      * StringUtil.rightPad("bat", 1)  = "bat" 
    750.      * StringUtil.rightPad("bat", -1) = "bat" 
    751.      * </pre> 
    752.      * 
    753.      * @param str 
    754.      *            源字符串 
    755.      * @param size 
    756.      *            指定的长度 
    757.      * @return String 
    758.      */  
    759.     public static String rightPad(String str, int size) {  
    760.         return rightPad(str, size, ' ');  
    761.     }  
    762.    
    763.     /** 
    764.      * 从右边截取字符串.</p> 
    765.      *  
    766.      * <pre> 
    767.      * StringUtil.right(null, *)    = null 
    768.      * StringUtil.right(*, -ve)     = "" 
    769.      * StringUtil.right("", *)      = "" 
    770.      * StringUtil.right("abc", 0)   = "" 
    771.      * StringUtil.right("abc", 2)   = "bc" 
    772.      * StringUtil.right("abc", 4)   = "abc" 
    773.      * </pre> 
    774.      *  
    775.      * @param str 
    776.      *            源字符串 
    777.      * @param len 
    778.      *            长度 
    779.      * @return String 
    780.      */  
    781.     public static String right(String str, int len) {  
    782.         if (str == null) {  
    783.             return null;  
    784.         }  
    785.         if (len < 0) {  
    786.             return EMPTY;  
    787.         }  
    788.         if (str.length() <= len) {  
    789.             return str;  
    790.         }  
    791.         return str.substring(str.length() - len);  
    792.     }  
    793.    
    794.     /** 
    795.      * <p> 
    796.      * 截取一个字符串的前几个. 
    797.      * </p> 
    798.      *  
    799.      * <pre> 
    800.      * StringUtil.left(null, *)    = null 
    801.      * StringUtil.left(*, -ve)     = "" 
    802.      * StringUtil.left("", *)      = "" 
    803.      * StringUtil.left("abc", 0)   = "" 
    804.      * StringUtil.left("abc", 2)   = "ab" 
    805.      * StringUtil.left("abc", 4)   = "abc" 
    806.      * </pre> 
    807.      *  
    808.      * @param str 
    809.      *            源字符串 
    810.      * @param len 
    811.      *            截取的长度 
    812.      * @return the String 
    813.      */  
    814.     public static String left(String str, int len) {  
    815.         if (str == null) {  
    816.             return null;  
    817.         }  
    818.         if (len < 0) {  
    819.             return EMPTY;  
    820.         }  
    821.         if (str.length() <= len) {  
    822.             return str;  
    823.         }  
    824.         return str.substring(0, len);  
    825.     }  
    826.    
    827.     /** 
    828.      * <p> 
    829.      * 得到tag字符串中间的子字符串，只返回第一个匹配项。 
    830.      * </p> 
    831.      *  
    832.      * <pre> 
    833.      * StringUtil.substringBetween(null, *)            = null 
    834.      * StringUtil.substringBetween("", "")             = "" 
    835.      * StringUtil.substringBetween("", "tag")          = null 
    836.      * StringUtil.substringBetween("tagabctag", null)  = null 
    837.      * StringUtil.substringBetween("tagabctag", "")    = "" 
    838.      * StringUtil.substringBetween("tagabctag", "tag") = "abc" 
    839.      * </pre> 
    840.      *  
    841.      * @param str 
    842.      *            源字符串。 
    843.      * @param tag 
    844.      *            标识字符串。 
    845.      * @return String 子字符串, 如果没有符合要求的，返回{@code null}。 
    846.      */  
    847.     public static String substringBetween(String str, String tag) {  
    848.         return substringBetween(str, tag, tag);  
    849.     }  
    850.    
    851.     /** 
    852.      * <p> 
    853.      * 得到两个字符串中间的子字符串，只返回第一个匹配项。 
    854.      * </p> 
    855.      *  
    856.      * <pre> 
    857.      * StringUtil.substringBetween("wx[b]yz", "[", "]") = "b" 
    858.      * StringUtil.substringBetween(null, *, *)          = null 
    859.      * StringUtil.substringBetween(*, null, *)          = null 
    860.      * StringUtil.substringBetween(*, *, null)          = null 
    861.      * StringUtil.substringBetween("", "", "")          = "" 
    862.      * StringUtil.substringBetween("", "", "]")         = null 
    863.      * StringUtil.substringBetween("", "[", "]")        = null 
    864.      * StringUtil.substringBetween("yabcz", "", "")     = "" 
    865.      * StringUtil.substringBetween("yabcz", "y", "z")   = "abc" 
    866.      * StringUtil.substringBetween("yabczyabcz", "y", "z")   = "abc" 
    867.      * </pre> 
    868.      *  
    869.      * @param str 
    870.      *            源字符串 
    871.      * @param open 
    872.      *            起字符串。 
    873.      * @param close 
    874.      *            末字符串。 
    875.      * @return String 子字符串, 如果没有符合要求的，返回{@code null}。 
    876.      */  
    877.     public static String substringBetween(String str, String open, String close) {  
    878.         if (str == null || open == null || close == null) {  
    879.             return null;  
    880.         }  
    881.         int start = str.indexOf(open);  
    882.         if (start != INDEX_NOT_FOUND) {  
    883.             int end = str.indexOf(close, start + open.length());  
    884.             if (end != INDEX_NOT_FOUND) {  
    885.                 return str.substring(start + open.length(), end);  
    886.             }  
    887.         }  
    888.         return null;  
    889.     }  
    890.    
    891.     /** 
    892.      * <p> 
    893.      * 得到两个字符串中间的子字符串，所有匹配项组合为数组并返回。 
    894.      * </p> 
    895.      *  
    896.      * <pre> 
    897.      * StringUtil.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"] 
    898.      * StringUtil.substringsBetween(null, *, *)            = null 
    899.      * StringUtil.substringsBetween(*, null, *)            = null 
    900.      * StringUtil.substringsBetween(*, *, null)            = null 
    901.      * StringUtil.substringsBetween("", "[", "]")          = [] 
    902.      * </pre> 
    903.      * 
    904.      * @param str 
    905.      *            源字符串 
    906.      * @param open 
    907.      *            起字符串。 
    908.      * @param close 
    909.      *            末字符串。 
    910.      * @return String 子字符串数组, 如果没有符合要求的，返回{@code null}。 
    911.      */  
    912.     public static String[] substringsBetween(String str, String open,  
    913.             String close) {  
    914.         if (str == null || isEmpty(open) || isEmpty(close)) {  
    915.             return null;  
    916.         }  
    917.         int strLen = str.length();  
    918.         if (strLen == 0) {  
    919.             return new String[0];  
    920.         }  
    921.         int closeLen = close.length();  
    922.         int openLen = open.length();  
    923.         List<String> list = new ArrayList<String>();  
    924.         int pos = 0;  
    925.         while (pos < strLen - closeLen) {  
    926.             int start = str.indexOf(open, pos);  
    927.             if (start < 0) {  
    928.                 break;  
    929.             }  
    930.             start += openLen;  
    931.             int end = str.indexOf(close, start);  
    932.             if (end < 0) {  
    933.                 break;  
    934.             }  
    935.             list.add(str.substring(start, end));  
    936.             pos = end + closeLen;  
    937.         }  
    938.         if (list.isEmpty()) {  
    939.             return null;  
    940.         }  
    941.         return list.toArray(new String[list.size()]);  
    942.     }  
    943.    
    944.     /** 
    945.      * 功能：切换字符串中的所有字母大小写。<br/> 
    946.      *  
    947.      * <pre> 
    948.      * StringUtil.swapCase(null)                 = null 
    949.      * StringUtil.swapCase("")                   = "" 
    950.      * StringUtil.swapCase("The dog has a BONE") = "tHE DOG HAS A bone" 
    951.      * </pre> 
    952.      *  
    953.      * 
    954.      * @param str 
    955.      *            源字符串 
    956.      * @return String 
    957.      */  
    958.     public static String swapCase(String str) {  
    959.         if (StringUtil.isEmpty(str)) {  
    960.             return str;  
    961.         }  
    962.         char[] buffer = str.toCharArray();  
    963.    
    964.         boolean whitespace = true;  
    965.    
    966.         for (int i = 0; i < buffer.length; i++) {  
    967.             char ch = buffer[i];  
    968.             if (Character.isUpperCase(ch)) {  
    969.                 buffer[i] = Character.toLowerCase(ch);  
    970.                 whitespace = false;  
    971.             } else if (Character.isTitleCase(ch)) {  
    972.                 buffer[i] = Character.toLowerCase(ch);  
    973.                 whitespace = false;  
    974.             } else if (Character.isLowerCase(ch)) {  
    975.                 if (whitespace) {  
    976.                     buffer[i] = Character.toTitleCase(ch);  
    977.                     whitespace = false;  
    978.                 } else {  
    979.                     buffer[i] = Character.toUpperCase(ch);  
    980.                 }  
    981.             } else {  
    982.                 whitespace = Character.isWhitespace(ch);  
    983.             }  
    984.         }  
    985.         return new String(buffer);  
    986.     }  
    987.    
    988.     /** 
    989.      * 功能：截取出最后一个标志位之后的字符串.<br/> 
    990.      * 如果sourceStr为empty或者expr为null，直接返回源字符串。<br/> 
    991.      * 如果expr长度为0，直接返回sourceStr。<br/> 
    992.      * 如果expr在sourceStr中不存在，直接返回sourceStr。<br/> 
    993.      *  
    994.      * @author 宋立君 
    995.      * @date 2014年06月24日 
    996.      * @param sourceStr 
    997.      *            被截取的字符串 
    998.      * @param expr 
    999.      *            分隔符 
    1000.      * @return String 
    1001.      */  
    1002.     public static String substringAfterLast(String sourceStr, String expr) {  
    1003.         if (isEmpty(sourceStr) || expr == null) {  
    1004.             return sourceStr;  
    1005.         }  
    1006.         if (expr.length() == 0) {  
    1007.             return sourceStr;  
    1008.         }  
    1009.    
    1010.         int pos = sourceStr.lastIndexOf(expr);  
    1011.         if (pos == -1) {  
    1012.             return sourceStr;  
    1013.         }  
    1014.         return sourceStr.substring(pos + expr.length());  
    1015.     }  
    1016.    
    1017.     /** 
    1018.      * 功能：截取出最后一个标志位之前的字符串.<br/> 
    1019.      * 如果sourceStr为empty或者expr为null，直接返回源字符串。<br/> 
    1020.      * 如果expr长度为0，直接返回sourceStr。<br/> 
    1021.      * 如果expr在sourceStr中不存在，直接返回sourceStr。<br/> 
    1022.      *  
    1023.      * @author 宋立君 
    1024.      * @date 2014年06月24日 
    1025.      * @param sourceStr 
    1026.      *            被截取的字符串 
    1027.      * @param expr 
    1028.      *            分隔符 
    1029.      * @return String 
    1030.      */  
    1031.     public static String substringBeforeLast(String sourceStr, String expr) {  
    1032.         if (isEmpty(sourceStr) || expr == null) {  
    1033.             return sourceStr;  
    1034.         }  
    1035.         if (expr.length() == 0) {  
    1036.             return sourceStr;  
    1037.         }  
    1038.         int pos = sourceStr.lastIndexOf(expr);  
    1039.         if (pos == -1) {  
    1040.             return sourceStr;  
    1041.         }  
    1042.         return sourceStr.substring(0, pos);  
    1043.     }  
    1044.    
    1045.     /** 
    1046.      * 功能：截取出第一个标志位之后的字符串.<br/> 
    1047.      * 如果sourceStr为empty或者expr为null，直接返回源字符串。<br/> 
    1048.      * 如果expr长度为0，直接返回sourceStr。<br/> 
    1049.      * 如果expr在sourceStr中不存在，直接返回sourceStr。<br/> 
    1050.      *  
    1051.      * @author 宋立君 
    1052.      * @date 2014年06月24日 
    1053.      * @param sourceStr 
    1054.      *            被截取的字符串 
    1055.      * @param expr 
    1056.      *            分隔符 
    1057.      * @return String 
    1058.      */  
    1059.     public static String substringAfter(String sourceStr, String expr) {  
    1060.         if (isEmpty(sourceStr) || expr == null) {  
    1061.             return sourceStr;  
    1062.         }  
    1063.         if (expr.length() == 0) {  
    1064.             return sourceStr;  
    1065.         }  
    1066.    
    1067.         int pos = sourceStr.indexOf(expr);  
    1068.         if (pos == -1) {  
    1069.             return sourceStr;  
    1070.         }  
    1071.         return sourceStr.substring(pos + expr.length());  
    1072.     }  
    1073.    
    1074.     /** 
    1075.      * 功能：截取出第一个标志位之前的字符串.<br/> 
    1076.      * 如果sourceStr为empty或者expr为null，直接返回源字符串。<br/> 
    1077.      * 如果expr长度为0，直接返回sourceStr。<br/> 
    1078.      * 如果expr在sourceStr中不存在，直接返回sourceStr。<br/> 
    1079.      * 如果expr在sourceStr中存在不止一个，以第一个位置为准。 
    1080.      *  
    1081.      * @author 宋立君 
    1082.      * @date 2014年06月24日 
    1083.      * @param sourceStr 
    1084.      *            被截取的字符串 
    1085.      * @param expr 
    1086.      *            分隔符 
    1087.      * @return String 
    1088.      */  
    1089.     public static String substringBefore(String sourceStr, String expr) {  
    1090.         if (isEmpty(sourceStr) || expr == null) {  
    1091.             return sourceStr;  
    1092.         }  
    1093.         if (expr.length() == 0) {  
    1094.             return sourceStr;  
    1095.         }  
    1096.         int pos = sourceStr.indexOf(expr);  
    1097.         if (pos == -1) {  
    1098.             return sourceStr;  
    1099.         }  
    1100.         return sourceStr.substring(0, pos);  
    1101.     }  
    1102.    
    1103.     /** 
    1104.      * 功能：检查这个字符串是不是空字符串。<br/> 
    1105.      * 如果这个字符串为null或者trim后为空字符串则返回true，否则返回false。 
    1106.      *  
    1107.      * @author 宋立君 
    1108.      * @date 2014年06月24日 
    1109.      * @param chkStr 
    1110.      *            被检查的字符串 
    1111.      * @return boolean 
    1112.      */  
    1113.     public static boolean isEmpty(String chkStr) {  
    1114.         if (chkStr == null) {  
    1115.             return true;  
    1116.         } else {  
    1117.             return "".equals(chkStr.trim()) ? true : false;  
    1118.         }  
    1119.     }  
    1120.    
    1121.     /** 
    1122.      * 如果字符串没有超过最长显示长度返回原字符串，否则从开头截取指定长度并加...返回。 
    1123.      *  
    1124.      * @param str 
    1125.      *            原字符串 
    1126.      * @param length 
    1127.      *            字符串最长显示的长度 
    1128.      * @return 转换后的字符串 
    1129.      */  
    1130.     public static String trimString(String str, int length) {  
    1131.         if (str == null) {  
    1132.             return "";  
    1133.         } else if (str.length() > length) {  
    1134.             return str.substring(0, length - 3) + "...";  
    1135.         } else {  
    1136.             return str;  
    1137.         }  
    1138.     }  
    1139.    
    1140. }  

    二、MD5
    [java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. package com.mkyong.common;  
    2.   
    3. import java.io.File;  
    4. import java.io.FileInputStream;  
    5. import java.io.IOException;  
    6. import java.nio.MappedByteBuffer;  
    7. import java.nio.channels.FileChannel;  
    8. import java.security.MessageDigest;  
    9. import java.security.NoSuchAlgorithmException;  
    10.   
    11. /** 
    12.  *  
    13.  * String工具类. <br> 
    14.  *  
    15.  * @author 宋立君 
    16.  * @date 2014年06月24日 
    17.  */  
    18. public class MD5Util {  
    19.   
    20.     protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',  
    21.             '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };  
    22.   
    23.     protected static MessageDigest messagedigest = null;  
    24.   
    25.     static {  
    26.         try {  
    27.             messagedigest = MessageDigest.getInstance("MD5");  
    28.         } catch (NoSuchAlgorithmException nsaex) {  
    29.             System.err.println(MD5Util.class.getName()  
    30.                     + "初始化失败，MessageDigest不支持MD5Util。");  
    31.             nsaex.printStackTrace();  
    32.         }  
    33.     }  
    34.   
    35.     /** 
    36.      * 功能：加盐版的MD5.返回格式为MD5(密码+{盐值}) 
    37.      *  
    38.      * @author 宋立君 
    39.      * @date 2014年06月24日 
    40.      * @param password 
    41.      *            密码 
    42.      * @param salt 
    43.      *            盐值 
    44.      * @return String 
    45.      */  
    46.     public static String getMD5StringWithSalt(String password, String salt) {  
    47.         if (password == null) {  
    48.             throw new IllegalArgumentException("password不能为null");  
    49.         }  
    50.         if (StringUtil.isEmpty(salt)) {  
    51.             throw new IllegalArgumentException("salt不能为空");  
    52.         }  
    53.         if ((salt.toString().lastIndexOf("{") != -1)  
    54.                 || (salt.toString().lastIndexOf("}") != -1)) {  
    55.             throw new IllegalArgumentException("salt中不能包含 { 或者 }");  
    56.         }  
    57.         return getMD5String(password + "{" + salt.toString() + "}");  
    58.     }  
    59.   
    60.     /** 
    61.      * 功能：得到文件的md5值。 
    62.      *  
    63.      * @author 宋立君 
    64.      * @date 2014年06月24日 
    65.      * @param file 
    66.      *            文件。 
    67.      * @return String 
    68.      * @throws IOException 
    69.      *             读取文件IO异常时。 
    70.      */  
    71.     public static String getFileMD5String(File file) throws IOException {  
    72.         FileInputStream in = new FileInputStream(file);  
    73.         FileChannel ch = in.getChannel();  
    74.         MappedByteBuffer byteBuffer = ch.map(FileChannel.MapMode.READ_ONLY, 0,  
    75.                 file.length());  
    76.         messagedigest.update(byteBuffer);  
    77.         return bufferToHex(messagedigest.digest());  
    78.     }  
    79.   
    80.     /** 
    81.      * 功能：得到一个字符串的MD5值。 
    82.      *  
    83.      * @author 宋立君 
    84.      * @date 2014年06月24日 
    85.      * @param str 
    86.      *            字符串 
    87.      * @return String 
    88.      */  
    89.     public static String getMD5String(String str) {  
    90.         return getMD5String(str.getBytes());  
    91.     }  
    92.   
    93.     private static String getMD5String(byte[] bytes) {  
    94.         messagedigest.update(bytes);  
    95.         return bufferToHex(messagedigest.digest());  
    96.     }  
    97.   
    98.     private static String bufferToHex(byte bytes[]) {  
    99.         return bufferToHex(bytes, 0, bytes.length);  
    100.     }  
    101.   
    102.     private static String bufferToHex(byte bytes[], int m, int n) {  
    103.         StringBuffer stringbuffer = new StringBuffer(2 * n);  
    104.         int k = m + n;  
    105.         for (int l = m; l < k; l++) {  
    106.             appendHexPair(bytes[l], stringbuffer);  
    107.         }  
    108.         return stringbuffer.toString();  
    109.     }  
    110.   
    111.     private static void appendHexPair(byte bt, StringBuffer stringbuffer) {  
    112.         char c0 = hexDigits[(bt & 0xf0) >> 4];  
    113.         char c1 = hexDigits[bt & 0xf];  
    114.         stringbuffer.append(c0);  
    115.         stringbuffer.append(c1);  
    116.     }  
    117. }  

    三、File工具类
    [java] view plaincopyprint?在CODE上查看代码片派生到我的代码片
    1. package com.mkyong.common;  
    2.   
    3. import java.io.ByteArrayInputStream;  
    4. import java.io.File;  
    5. import java.io.FileInputStream;  
    6. import java.io.FileOutputStream;  
    7. import java.io.IOException;  
    8. import java.io.InputStream;  
    9. import java.io.OutputStream;  
    10.   
    11. /** 
    12.  * 文件相关操作辅助类。 
    13.  *  
    14.  * @author 宋立君 
    15.  * @date 2014年06月24日 
    16.  */  
    17. public class FileUtil {  
    18.     private static final String FOLDER_SEPARATOR = "/";  
    19.     private static final char EXTENSION_SEPARATOR = '.';  
    20.   
    21.     /** 
    22.      * 功能：复制文件或者文件夹。 
    23.      *  
    24.      * @author 宋立君 
    25.      * @date 2014年06月24日 
    26.      * @param inputFile 
    27.      *            源文件 
    28.      * @param outputFile 
    29.      *            目的文件 
    30.      * @param isOverWrite 
    31.      *            是否覆盖(只针对文件) 
    32.      * @throws IOException 
    33.      */  
    34.     public static void copy(File inputFile, File outputFile, boolean isOverWrite)  
    35.             throws IOException {  
    36.         if (!inputFile.exists()) {  
    37.             throw new RuntimeException(inputFile.getPath() + "源目录不存在!");  
    38.         }  
    39.         copyPri(inputFile, outputFile, isOverWrite);  
    40.     }  
    41.   
    42.     /** 
    43.      * 功能：为copy 做递归使用。 
    44.      *  
    45.      * @author 宋立君 
    46.      * @date 2014年06月24日 
    47.      * @param inputFile 
    48.      * @param outputFile 
    49.      * @param isOverWrite 
    50.      * @throws IOException 
    51.      */  
    52.     private static void copyPri(File inputFile, File outputFile,  
    53.             boolean isOverWrite) throws IOException {  
    54.         // 是个文件。  
    55.         if (inputFile.isFile()) {  
    56.             copySimpleFile(inputFile, outputFile, isOverWrite);  
    57.         } else {  
    58.             // 文件夹  
    59.             if (!outputFile.exists()) {  
    60.                 outputFile.mkdir();  
    61.             }  
    62.             // 循环子文件夹  
    63.             for (File child : inputFile.listFiles()) {  
    64.                 copy(child,  
    65.                         new File(outputFile.getPath() + "/" + child.getName()),  
    66.                         isOverWrite);  
    67.             }  
    68.         }  
    69.     }  
    70.   
    71.     /** 
    72.      * 功能：copy单个文件 
    73.      *  
    74.      * @author 宋立君 
    75.      * @date 2014年06月24日 
    76.      * @param inputFile 
    77.      *            源文件 
    78.      * @param outputFile 
    79.      *            目标文件 
    80.      * @param isOverWrite 
    81.      *            是否允许覆盖 
    82.      * @throws IOException 
    83.      */  
    84.     private static void copySimpleFile(File inputFile, File outputFile,  
    85.             boolean isOverWrite) throws IOException {  
    86.         // 目标文件已经存在  
    87.         if (outputFile.exists()) {  
    88.             if (isOverWrite) {  
    89.                 if (!outputFile.delete()) {  
    90.                     throw new RuntimeException(outputFile.getPath() + "无法覆盖！");  
    91.                 }  
    92.             } else {  
    93.                 // 不允许覆盖  
    94.                 return;  
    95.             }  
    96.         }  
    97.         InputStream in = new FileInputStream(inputFile);  
    98.         OutputStream out = new FileOutputStream(outputFile);  
    99.         byte[] buffer = new byte[1024];  
    100.         int read = 0;  
    101.         while ((read = in.read(buffer)) != -1) {  
    102.             out.write(buffer, 0, read);  
    103.         }  
    104.         in.close();  
    105.         out.close();  
    106.     }  
    107.   
    108.     /** 
    109.      * 功能：删除文件 
    110.      *  
    111.      * @author 宋立君 
    112.      * @date 2014年06月24日 
    113.      * @param file 
    114.      *            文件 
    115.      */  
    116.     public static void delete(File file) {  
    117.         deleteFile(file);  
    118.     }  
    119.   
    120.     /** 
    121.      * 功能：删除文件，内部递归使用 
    122.      *  
    123.      * @author 宋立君 
    124.      * @date 2014年06月24日 
    125.      * @param file 
    126.      *            文件 
    127.      * @return boolean true 删除成功，false 删除失败。 
    128.      */  
    129.     private static void deleteFile(File file) {  
    130.         if (file == null || !file.exists()) {  
    131.             return;  
    132.         }  
    133.         // 单文件  
    134.         if (!file.isDirectory()) {  
    135.             boolean delFlag = file.delete();  
    136.             if (!delFlag) {  
    137.                 throw new RuntimeException(file.getPath() + "删除失败！");  
    138.             } else {  
    139.                 return;  
    140.             }  
    141.         }  
    142.         // 删除子目录  
    143.         for (File child : file.listFiles()) {  
    144.             deleteFile(child);  
    145.         }  
    146.         // 删除自己  
    147.         file.delete();  
    148.     }  
    149.   
    150.     /** 
    151.      * 从文件路径中抽取文件的扩展名, 例如. "mypath/myfile.txt" -> "txt". * @author 宋立君 
    152.      *  
    153.      * @date 2014年06月24日 
    154.      * @param 文件路径 
    155.      * @return 如果path为null，直接返回null。 
    156.      */  
    157.     public static String getFilenameExtension(String path) {  
    158.         if (path == null) {  
    159.             return null;  
    160.         }  
    161.         int extIndex = path.lastIndexOf(EXTENSION_SEPARATOR);  
    162.         if (extIndex == -1) {  
    163.             return null;  
    164.         }  
    165.         int folderIndex = path.lastIndexOf(FOLDER_SEPARATOR);  
    166.         if (folderIndex > extIndex) {  
    167.             return null;  
    168.         }  
    169.         return path.substring(extIndex + 1);  
    170.     }  
    171.   
    172.     /** 
    173.      * 从文件路径中抽取文件名, 例如： "mypath/myfile.txt" -> "myfile.txt"。 * @author 宋立君 
    174.      *  
    175.      * @date 2014年06月24日 
    176.      * @param path 
    177.      *            文件路径。 
    178.      * @return 抽取出来的文件名, 如果path为null，直接返回null。 
    179.      */  
    180.     public static String getFilename(String path) {  
    181.         if (path == null) {  
    182.             return null;  
    183.         }  
    184.         int separatorIndex = path.lastIndexOf(FOLDER_SEPARATOR);  
    185.         return (separatorIndex != -1 ? path.substring(separatorIndex + 1)  
    186.                 : path);  
    187.     }  
    188.   
    189.     /** 
    190.      * 功能：保存文件。 
    191.      *  
    192.      * @author 宋立君 
    193.      * @date 2014年06月24日 
    194.      * @param content 
    195.      *            字节 
    196.      * @param file 
    197.      *            保存到的文件 
    198.      * @throws IOException 
    199.      */  
    200.     public static void save(byte[] content, File file) throws IOException {  
    201.         if (file == null) {  
    202.             throw new RuntimeException("保存文件不能为空");  
    203.         }  
    204.         if (content == null) {  
    205.             throw new RuntimeException("文件流不能为空");  
    206.         }  
    207.         InputStream is = new ByteArrayInputStream(content);  
    208.         save(is, file);  
    209.     }  
    210.   
    211.     /** 
    212.      * 功能：保存文件 
    213.      *  
    214.      * @author 宋立君 
    215.      * @date 2014年06月24日 
    216.      * @param streamIn 
    217.      *            文件流 
    218.      * @param file 
    219.      *            保存到的文件 
    220.      * @throws IOException 
    221.      */  
    222.     public static void save(InputStream streamIn, File file) throws IOException {  
    223.         if (file == null) {  
    224.             throw new RuntimeException("保存文件不能为空");  
    225.         }  
    226.         if (streamIn == null) {  
    227.             throw new RuntimeException("文件流不能为空");  
    228.         }  
    229.         // 输出流  
    230.         OutputStream streamOut = null;  
    231.         // 文件夹不存在就创建。  
    232.         if (!file.getParentFile().exists()) {  
    233.             file.getParentFile().mkdirs();  
    234.         }  
    235.         streamOut = new FileOutputStream(file);  
    236.         int bytesRead = 0;  
    237.         byte[] buffer = new byte[8192];  
    238.         while ((bytesRead = streamIn.read(buffer, 0, 8192)) != -1) {  
    239.             streamOut.write(buffer, 0, bytesRead);  
    240.         }  
    241.         streamOut.close();  
    242.         streamIn.close();  
    243.     }  
    244. }  
  • 相关阅读:
    pat 甲级 1065. A+B and C (64bit) (20)
    pat 甲级 1064. Complete Binary Search Tree (30)
    pat 甲级 1010. Radix (25)
    pat 甲级 1009. Product of Polynomials (25)
    pat 甲级 1056. Mice and Rice (25)
    pat 甲级 1078. Hashing (25)
    pat 甲级 1080. Graduate Admission (30)
    pat 甲级 团体天梯 L3-004. 肿瘤诊断
    pat 甲级 1099. Build A Binary Search Tree (30)
    Codeforce 672B. Different is Good
  • 原文地址：https://www.cnblogs.com/archermeng/p/7537613.html
Copyright © 2020-2023  润新知