摘自：https://github.com/cundong/ZhihuPaper

import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.json.JSONException;
import org.json.JSONObject;

/**
 * 類說明： 字串操作類
 * 
 * @author Cundong
 * @date Feb 7, 2012 2:51:58 AM
 * @version 1.0
 */
public class StringUtils {
	public static final String[] EMPTY_STRING = new String[0];

	/**
	 * 判斷給定字串是否空白串。<br>
	 * 空白串是指由空格、製表符、回車符、換行符組成的字串<br>
	 * 若輸入字串為null或空字串，返回true
	 * 
	 * @param input
	 * @return boolean
	 */
	public static boolean isBlank(String input) {
		if (input == null || "".equals(input))
			return true;

		for (int i = 0; i < input.length(); i++) {
			char c = input.charAt(i);
			if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
				return false;
			}
		}
		return true;
	}

	/**
	 * 若輸入為null，則返回空字串；否則返回字串自身
	 * 
	 * @param
	 * @return
	 */
	public static String getNotNull(String input) {
		return (input == null ? "" : input);
	}

	public static String getNotNull(String input, String defaultValue) {
		return (isBlank(input) ? defaultValue : input);
	}

	/**
	 * 擷取字串末尾空格
	 * 
	 * @param input
	 * @return
	 */
	public static String trim(String input) {
		if (isBlank(input))
			return "";
		return input.trim();
	}

	/**
	 * 根據指定分隔符分割字串，返回結果陣列。<br>
	 * 處理規則：<br>
	 * 若輸入為null，則返回null；<br>
	 * 否則若輸入為空字串，則返回空陣列；<br>
	 * 否則若分隔符為null或空字串，則返回包含原字串本身的陣列；<br>
	 * 
	 * @param input
	 *            輸入字串
	 * @param separator
	 *            分隔符
	 * @return 結果陣列（注意：包括空字串）
	 */
	public static String[] split(String input, String separator) {
		if (input == null)
			return null;
		if (input.equals(""))
			return EMPTY_STRING;
		if (separator == null || "".equals(separator))
			return new String[] { input };

		int cursor = 0; // 遊標
		int lastPos = 0; // 指向上一個分隔符後第一個字元
		ArrayList<String> list = new ArrayList<String>();

		while ((cursor = input.indexOf(separator, cursor)) != -1) {

			String token = input.substring(lastPos, cursor);
			list.add(token);

			lastPos = cursor + separator.length();

			cursor = lastPos;
		}

		if (lastPos < input.length())
			list.add(input.substring(lastPos));

		return (String[]) list.toArray(new String[list.size()]);
	}

	/**
	 * 字串替換
	 * 
	 * @param source
	 * @param oldstring
	 * @param newstring
	 * @param caseInsensive
	 * @return
	 */
	public static String replaceString(String source, String oldstring, String newstring, boolean caseInsensive) {
		Matcher matcher = null;

		// 區分大小寫
		if (caseInsensive) {
			matcher = Pattern.compile(oldstring, Pattern.CASE_INSENSITIVE).matcher(source);
		} else {
			matcher = Pattern.compile(oldstring).matcher(source);
		}

		return matcher.replaceAll(newstring);
	}

	/**
	 * 清除字串末尾的特定字元<br>
	 * 若字串末尾並非給定字元，則什麼都不做<br>
	 * 注意：該方法改變了傳入的StringBuffer引數的值
	 * 
	 * @param sb
	 *            字串快取
	 * @param tail
	 *            使用者給定字元
	 * @return 字串快取物件的字串表示
	 */
	public static String trimTail(StringBuffer sb, char tail) {
		if (sb.length() > 0 && sb.charAt(sb.length() - 1) == tail)
			sb.deleteCharAt(sb.length() - 1);
		return sb.toString();
	}

	/**
	 * 根據指定分隔符分割字串，返回結果陣列。<br>
	 * 處理規則：<br>
	 * 若輸入為null，則返回null；<br>
	 * 否則若輸入為空字串，則返回空陣列；<br>
	 * 否則若分隔符為null或空字串，則返回包含原字串本身的陣列；<br>
	 * 注意：返回結果中過濾掉空字串
	 * 
	 * @param input
	 *            輸入字串(數字字串)
	 * @param separator
	 *            分隔符
	 * @return 結果陣列（注意：不包括空字串）
	 */
	public static Integer[] splitInt(String input, String separator) {
		if (input == null)
			return null;
		if (input.equals(""))
			return null;
		if (separator == null || "".equals(separator))
			return null;

		int cursor = 0; // 遊標
		int lastPos = 0; // 指向上一個分隔符後第一個字元
		ArrayList<Integer> list = new ArrayList<Integer>();

		while ((cursor = input.indexOf(separator, cursor)) != -1) {

			if (cursor > lastPos) {// 濾掉空字串
				int token = Integer.parseInt(input.substring(lastPos, cursor));
				list.add(token);
			}

			lastPos = cursor + separator.length();

			cursor = lastPos;
		}

		if (lastPos < input.length())
			list.add(Integer.parseInt(input.substring(lastPos)));

		Integer[] iStrToI = new Integer[list.size()];
		for (int i = 0; i < list.size(); i++) {
			iStrToI[i] = Integer.parseInt(list.get(i).toString());
		}
		return iStrToI;
	}

	/**
	 * 字串的轉義(處理特殊字元)
	 * 
	 * @param input
	 * @return
	 */
	public static String StringToString(String input) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < input.length(); i++) {
			char c = input.toCharArray()[i];
			switch (c) {
			case '\'':
				sb.append("\\\'");
				break;
			case '\"':
				sb.append("\\\"");
				break;
			case '\\':
				sb.append("\\\\");
				break;
			case '/':
				sb.append("\\/");
				break;
			case '\b':
				sb.append("\\b");
				break;
			case '\f':
				sb.append("\\f");
				break;
			case '\n':
				sb.append("\\n");
				break;
			case '\r':
				sb.append("\\r");
				break;
			case '\t':
				sb.append("\\t");
				break;
			default:
				sb.append(c);
				break;
			}
		}
		return sb.toString();
	}

	/**
	 * list 轉換為 string
	 * 
	 * @param list
	 * @param flag
	 * @return
	 */
	public static String listToString(ArrayList<String> list, String flag) {
		String strMsg = "";
		int listSize = list.size();
		if (listSize > 0) {
			for (int i = 0; i < listSize; i++) {
				if (i == listSize - 1) {
					strMsg = strMsg + list.get(i).toString();
				} else {
					strMsg = strMsg + list.get(i).toString() + flag;
				}
			}
		} else {
			strMsg = "";
		}
		return strMsg;
	}

	/**
	 * 字串轉換為arraylist(必須符合這樣的格式([{"a":"a","b":"b"}，{"a":"a","b":"b"}，{}]))
	 * 
	 * @param strList
	 * @return (成功為 arrayList 失敗 Exception)
	 * 
	 */
	public static ArrayList<Object> strToList(String strList) {

		JSONObject oJsonObj = null;
		ArrayList<Object> listStr = new ArrayList<Object>();
		int iStriList = strList.length(); // 長度
		String strDemoList = strList.substring(1, iStriList - 1);// 幹掉 []
		String[] arrInfo = StringUtils.split(strDemoList, "},");
		int iArrInfo = arrInfo.length;
		for (int i = 0; i < iArrInfo; i++) {
			HashMap<String, String> paperMsg = new HashMap<String, String>();
			try {
				if (!arrInfo[i].endsWith("}")) {
					oJsonObj = new JSONObject(arrInfo[i] + "}");
				} else {
					oJsonObj = new JSONObject(arrInfo[i]);
				}
				Iterator<?> iter2 = oJsonObj.keys();
				while (iter2.hasNext()) {
					String key = iter2.next().toString();
					paperMsg.put(key, oJsonObj.get(key).toString());
				}
				listStr.add(paperMsg);// 新增list
			} catch (JSONException e) {

				// 出現異常 清空List
				listStr.clear();
				listStr.add(0, "Exception");
			}
		}
		return listStr;
	}

	/**
	 * InputStream轉為字串
	 * 
	 * @param in
	 * @return
	 */
	public static String toString(InputStream in) throws IOException {
		StringBuffer out = new StringBuffer();
		byte[] buffer = new byte[1024];
		for (int i; (i = in.read(buffer)) != -1;) {
			out.append(new String(buffer, 0, i));
		}
		return out.toString();
	}

	/**
	 * 對字串中的中文進行編碼
	 * 
	 * @param inputUrl
	 * @return
	 */
	public static String encodeUrl(String inputUrl) {

		if (isBlank(inputUrl))
			return inputUrl;

		char[] charArray = inputUrl.toCharArray();
		for (int i = 0; i < charArray.length; i++) {
			if ((charArray[i] >= 0x4e00) && (charArray[i] <= 0x9fbb)) {
				inputUrl = inputUrl.replaceFirst(String.valueOf(charArray[i]), URLEncoder.encode(String.valueOf(charArray[i])));

			}
		}
		return inputUrl;
	}

	/**
	 * 擷取字串
	 * 
	 * @param inputUrl
	 * @param length
	 * @return
	 */
	public static String subString(String inputUrl, int length) {
		if (isBlank(inputUrl))
			return inputUrl;

		if (inputUrl.length() > length) {
			return inputUrl.substring(0, length);
		} else {
			return inputUrl;
		}
	}
}