String工具类，可用于常见字符串操作，如：
isEmpty(String str) 判断字符串是否为空或长度为0
isBlank(String str) 判断字符串是否为空或长度为0 或由空格组成
utf8Encode(String str) 以utf-8格式编码
capitalizeFirstLetter(String str) 首字母大写
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* String Utils
*
* @author <a href="http://www.trinea.cn" target="_blank">Trinea</a> 2011-7-22
*/
public class StringUtils {
private StringUtils() {
throw new AssertionError();
}
/**
* is null or its length is 0 or it is made by space
*
* <pre>
* isBlank(null) = true;
* isBlank("") = true;
* isBlank(" ") = true;
* isBlank("a") = false;
* isBlank("a ") = false;
* isBlank(" a") = false;
* isBlank("a b") = false;
* </pre>
*
* @param str
* @return if string is null or its size is 0 or it is made by space, return true, else return false.
*/
public static boolean isBlank(String str) {
return (str == null || str.trim().length() == 0);
}
/**
* is null or its length is 0
*
* <pre>
* isEmpty(null) = true;
* isEmpty("") = true;
* isEmpty(" ") = false;
* </pre>
*
* @param str
* @return if string is null or its size is 0, return true, else return false.
*/
public static boolean isEmpty(CharSequence str) {
return (str == null || str.length() == 0);
}
/**
* compare two string
*
* @param actual
* @param expected
* @return
* @see ObjectUtils#isEquals(Object, Object)
*/
public static boolean isEquals(String actual, String expected) {
return ObjectUtils.isEquals(actual, expected);
}
/**
* get length of CharSequence
*
* <pre>
* length(null) = 0;
* length(\"\") = 0;
* length(\"abc\") = 3;
* </pre>
*
* @param str
* @return if str is null or empty, return 0, else return {@link CharSequence#length()}.
*/
public static int length(CharSequence str) {
return str == null ? 0 : str.length();
}
/**
* null Object to empty string
*
* <pre>
* nullStrToEmpty(null) = "";
* nullStrToEmpty("") = "";
* nullStrToEmpty("aa") = "aa";
* </pre>
*
* @param str
* @return
*/
public static String nullStrToEmpty(Object str) {
return (str == null ? "" : (str instanceof String ? (String)str : str.toString()));
}
/**
* capitalize first letter
*
* <pre>
* capitalizeFirstLetter(null) = null;
* capitalizeFirstLetter("") = "";
* capitalizeFirstLetter("2ab") = "2ab"
* capitalizeFirstLetter("a") = "A"
* capitalizeFirstLetter("ab") = "Ab"
* capitalizeFirstLetter("Abc") = "Abc"
* </pre>
*
* @param str
* @return
*/
public static String capitalizeFirstLetter(String str) {
if (isEmpty(str)) {
return str;
}
char c = str.charAt(0);
return (!Character.isLetter(c) || Character.isUpperCase(c)) ? str : new StringBuilder(str.length())
.append(Character.toUpperCase(c)).append(str.substring(1)).toString();
}
/**
* encoded in utf-8
*
* <pre>
* utf8Encode(null) = null
* utf8Encode("") = "";
* utf8Encode("aa") = "aa";
* utf8Encode("啊啊啊啊") = "%E5%95%8A%E5%95%8A%E5%95%8A%E5%95%8A";
* </pre>
*
* @param str
* @return
* @throws UnsupportedEncodingException if an error occurs
*/
public static String utf8Encode(String str) {
if (!isEmpty(str) && str.getBytes().length != str.length()) {
try {
return URLEncoder.encode(str, "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("UnsupportedEncodingException occurred. ", e);
}
}
return str;
}
/**
* encoded in utf-8, if exception, return defultReturn
*
* @param str
* @param defultReturn
* @return
*/
public static String utf8Encode(String str, String defultReturn) {
if (!isEmpty(str) && str.getBytes().length != str.length()) {
try {
return URLEncoder.encode(str, "UTF-8");
} catch (UnsupportedEncodingException e) {
return defultReturn;
}
}
return str;
}
/**
* get innerHtml from href
*
* <pre>
* getHrefInnerHtml(null) = ""
* getHrefInnerHtml("") = ""
* getHrefInnerHtml("mp3") = "mp3";
* getHrefInnerHtml("<a innerHtml</a>") = "<a innerHtml</a>";
* getHrefInnerHtml("<a>innerHtml</a>") = "innerHtml";
* getHrefInnerHtml("<a<a>innerHtml</a>") = "innerHtml";
* getHrefInnerHtml("<a href="baidu.com">innerHtml</a>") = "innerHtml";
* getHrefInnerHtml("<a href="baidu.com" title="baidu">innerHtml</a>") = "innerHtml";
* getHrefInnerHtml(" <a>innerHtml</a> ") = "innerHtml";
* getHrefInnerHtml("<a>innerHtml</a></a>") = "innerHtml";
* getHrefInnerHtml("jack<a>innerHtml</a></a>") = "innerHtml";
* getHrefInnerHtml("<a>innerHtml1</a><a>innerHtml2</a>") = "innerHtml2";
* </pre>
*
* @param href
* @return <ul>
* <li>if href is null, return ""</li>
* <li>if not match regx, return source</li>
* <li>return the last string that match regx</li>
* </ul>
*/
public static String getHrefInnerHtml(String href) {
if (isEmpty(href)) {
return "";
}
String hrefReg = ".*<[\\s]*a[\\s]*.*>(.+?)<[\\s]*/a[\\s]*>.*";
Pattern hrefPattern = Pattern.compile(hrefReg, Pattern.CASE_INSENSITIVE);
Matcher hrefMatcher = hrefPattern.matcher(href);
if (hrefMatcher.matches()) {
return hrefMatcher.group(1);
}
return href;
}
/**
* process special char in html
*
* <pre>
* htmlEscapeCharsToString(null) = null;
* htmlEscapeCharsToString("") = "";
* htmlEscapeCharsToString("mp3") = "mp3";
* htmlEscapeCharsToString("mp3<") = "mp3<";
* htmlEscapeCharsToString("mp3>") = "mp3\>";
* htmlEscapeCharsToString("mp3&mp4") = "mp3&mp4";
* htmlEscapeCharsToString("mp3"mp4") = "mp3\"mp4";
* htmlEscapeCharsToString("mp3<>&"mp4") = "mp3\<\>&\"mp4";
* </pre>
*
* @param source
* @return
*/
public static String htmlEscapeCharsToString(String source) {
return StringUtils.isEmpty(source) ? source : source.replaceAll("<", "<").replaceAll(">", ">")
.replaceAll("&", "&").replaceAll(""", "\"");
}
/**
* transform half width char to full width char
*
* <pre>
* fullWidthToHalfWidth(null) = null;
* fullWidthToHalfWidth("") = "";
* fullWidthToHalfWidth(new String(new char[] {12288})) = " ";
* fullWidthToHalfWidth("！＂＃＄％＆) = "!\"#$%&";
* </pre>
*
* @param s
* @return
*/
public static String fullWidthToHalfWidth(String s) {
if (isEmpty(s)) {
return s;
}
char[] source = s.toCharArray();
for (int i = 0; i < source.length; i++) {
if (source[i] == 12288) {
source[i] = ' ';
// } else if (source[i] == 12290) {
// source[i] = '.';
} else if (source[i] >= 65281 && source[i] <= 65374) {
source[i] = (char)(source[i] - 65248);
} else {
source[i] = source[i];
}
}
return new String(source);
}
/**
* transform full width char to half width char
*
* <pre>
* halfWidthToFullWidth(null) = null;
* halfWidthToFullWidth("") = "";
* halfWidthToFullWidth(" ") = new String(new char[] {12288});
* halfWidthToFullWidth("!\"#$%&) = "！＂＃＄％＆";
* </pre>
*
* @param s
* @return
*/
public static String halfWidthToFullWidth(String s) {
if (isEmpty(s)) {
return s;
}
char[] source = s.toCharArray();
for (int i = 0; i < source.length; i++) {
if (source[i] == ' ') {
source[i] = (char)12288;
// } else if (source[i] == '.') {
// source[i] = (char)12290;
} else if (source[i] >= 33 && source[i] <= 126) {
source[i] = (char)(source[i] + 65248);
} else {
source[i] = source[i];
}
}
return new String(source);
}
} RandomUtils
随机数工具类，可用于获取固定大小固定字符内的随机数，如：
getRandom(char[] sourceChar, int length) 生成随机字符串，所有字符均在某个字符串内
getRandomNumbers(int length) 生成随机数字
import java.util.Random;
/**
* Random Utils
* <ul>
* Shuffling algorithm
* <li>{@link #shuffle(Object[])} Shuffling algorithm, Randomly permutes the specified array using a default source of
* randomness</li>
* <li>{@link #shuffle(Object[], int)} Shuffling algorithm, Randomly permutes the specified array</li>
* <li>{@link #shuffle(int[])} Shuffling algorithm, Randomly permutes the specified int array using a default source of
* randomness</li>
* <li>{@link #shuffle(int[], int)} Shuffling algorithm, Randomly permutes the specified int array</li>
* </ul>
* <ul>
* get random int
* <li>{@link #getRandom(int)} get random int between 0 and max</li>
* <li>{@link #getRandom(int, int)} get random int between min and max</li>
* </ul>
* <ul>
* get random numbers or letters
* <li>{@link #getRandomCapitalLetters(int)} get a fixed-length random string, its a mixture of uppercase letters</li>
* <li>{@link #getRandomLetters(int)} get a fixed-length random string, its a mixture of uppercase and lowercase letters
* </li>
* <li>{@link #getRandomLowerCaseLetters(int)} get a fixed-length random string, its a mixture of lowercase letters</li>
* <li>{@link #getRandomNumbers(int)} get a fixed-length random string, its a mixture of numbers</li>
* <li>{@link #getRandomNumbersAndLetters(int)} get a fixed-length random string, its a mixture of uppercase, lowercase
* letters and numbers</li>
* <li>{@link #getRandom(String, int)} get a fixed-length random string, its a mixture of chars in source</li>
* <li>{@link #getRandom(char[], int)} get a fixed-length random string, its a mixture of chars in sourceChar</li>
* </ul>
*/
public class RandomUtils {
public static final String NUMBERS_AND_LETTERS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String NUMBERS = "0123456789";
public static final String LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String CAPITAL_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String LOWER_CASE_LETTERS = "abcdefghijklmnopqrstuvwxyz";
private RandomUtils() {
throw new AssertionError();
}
/**
* get a fixed-length random string, its a mixture of uppercase, lowercase letters and numbers
*
* @param length
* @return
* @see RandomUtils#getRandom(String source, int length)
*/
public static String getRandomNumbersAndLetters(int length) {
return getRandom(NUMBERS_AND_LETTERS, length);
}
/**
* get a fixed-length random string, its a mixture of numbers
*
* @param length
* @return
* @see RandomUtils#getRandom(String source, int length)
*/
public static String getRandomNumbers(int length) {
return getRandom(NUMBERS, length);
}
/**
* get a fixed-length random string, its a mixture of uppercase and lowercase letters
*
* @param length
* @return
* @see RandomUtils#getRandom(String source, int length)
*/
public static String getRandomLetters(int length) {
return getRandom(LETTERS, length);
}
/**
* get a fixed-length random string, its a mixture of uppercase letters
*
* @param length
* @return
* @see RandomUtils#getRandom(String source, int length)
*/
public static String getRandomCapitalLetters(int length) {
return getRandom(CAPITAL_LETTERS, length);
}
/**
* get a fixed-length random string, its a mixture of lowercase letters
*
* @param length
* @return
* @see RandomUtils#getRandom(String source, int length)
*/
public static String getRandomLowerCaseLetters(int length) {
return getRandom(LOWER_CASE_LETTERS, length);
}
/**
* get a fixed-length random string, its a mixture of chars in source
*
* @param source
* @param length
* @return <ul>
* <li>if source is null or empty, return null</li>
* <li>else see {@link RandomUtils#getRandom(char[] sourceChar, int length)}</li>
* </ul>
*/
public static String getRandom(String source, int length) {
return StringUtils.isEmpty(source) ? null : getRandom(source.toCharArray(), length);
}
/**
* get a fixed-length random string, its a mixture of chars in sourceChar
*
* @param sourceChar
* @param length
* @return <ul>
* <li>if sourceChar is null or empty, return null</li>
* <li>if length less than 0, return null</li>
* </ul>
*/
public static String getRandom(char[] sourceChar, int length) {
if (sourceChar == null || sourceChar.length == 0 || length < 0) {
return null;
}
StringBuilder str = new StringBuilder(length);
Random random = new Random();
for (int i = 0; i < length; i++) {
str.append(sourceChar[random.nextInt(sourceChar.length)]);
}
return str.toString();
}
/**
* get random int between 0 and max
*
* @param max
* @return <ul>
* <li>if max <= 0, return 0</li>
* <li>else return random int between 0 and max</li>
* </ul>
*/
public static int getRandom(int max) {
return getRandom(0, max);
}
/**
* get random int between min and max
*
* @param min
* @param max
* @return <ul>
* <li>if min > max, return 0</li>
* <li>if min == max, return min</li>
* <li>else return random int between min and max</li>
* </ul>
*/
public static int getRandom(int min, int max) {
if (min > max) {
return 0;
}
if (min == max) {
return min;
}
return min + new Random().nextInt(max - min);
}
/**
* Shuffling algorithm, Randomly permutes the specified array using a default source of randomness
*
* @param objArray
* @return
*/
public static boolean shuffle(Object[] objArray) {
if (objArray == null) {
return false;
}
return shuffle(objArray, getRandom(objArray.length));
}
/**
* Shuffling algorithm, Randomly permutes the specified array
*
* @param objArray
* @param shuffleCount
* @return
*/
public static boolean shuffle(Object[] objArray, int shuffleCount) {
int length;
if (objArray == null || shuffleCount < 0 || (length = objArray.length) < shuffleCount) {
return false;
}
for (int i = 1; i <= shuffleCount; i++) {
int random = getRandom(length - i);
Object temp = objArray[length - i];
objArray[length - i] = objArray[random];
objArray[random] = temp;
}
return true;
}
/**
* Shuffling algorithm, Randomly permutes the specified int array using a default source of randomness
*
* @param intArray
* @return
*/
public static int[] shuffle(int[] intArray) {
if (intArray == null) {
return null;
}
return shuffle(intArray, getRandom(intArray.length));
}
/**
* Shuffling algorithm, Randomly permutes the specified int array
*
* @param intArray
* @param shuffleCount
* @return
*/
public static int[] shuffle(int[] intArray, int shuffleCount) {
int length;
if (intArray == null || shuffleCount < 0 || (length = intArray.length) < shuffleCount) {
return null;
}
int[] out = new int[shuffleCount];
for (int i = 1; i <= shuffleCount; i++) {
int random = getRandom(length - i);
out[i - 1] = intArray[random];
int temp = intArray[length - i];
intArray[length - i] = intArray[random];
intArray[random] = temp;
}
return out;
}
}SerializeUtils
序列化工具类，可用于序列化对象到文件或从文件反序列化对象，如：
deserialization(String filePath) 从文件反序列化对象
serialization(String filePath, Object obj) 序列化对象到文件
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* Serialize Utils
*
* @author <a href="http://www.trinea.cn" target="_blank">Trinea</a> 2012-5-14
*/
public class SerializeUtils {
private SerializeUtils() {
throw new AssertionError();
}
/**
* Deserialization object from file.
*
* @param filePath file path
* @return de-serialized object
* @throws RuntimeException if an error occurs
*/
public static Object deserialization(String filePath) {
ObjectInputStream in = null;
try {
in = new ObjectInputStream(new FileInputStream(filePath));
Object o = in.readObject();
in.close();
return o;
} catch (FileNotFoundException e) {
throw new RuntimeException("FileNotFoundException occurred. ", e);
} catch (ClassNotFoundException e) {
throw new RuntimeException("ClassNotFoundException occurred. ", e);
} catch (IOException e) {
throw new RuntimeException("IOException occurred. ", e);
} finally {
IOUtils.close(in);
}
}
/**
* Serialize object to file.
*
* @param filePath file path
* @param obj object
* @throws RuntimeException if an error occurs
*/
public static void serialization(String filePath, Object obj) {
ObjectOutputStream out = null;
try {
out = new ObjectOutputStream(new FileOutputStream(filePath));
out.writeObject(obj);
out.close();
} catch (FileNotFoundException e) {
throw new RuntimeException("FileNotFoundException occurred. ", e);
} catch (IOException e) {
throw new RuntimeException("IOException occurred. ", e);
} finally {
IOUtils.close(out);
}
}
} JSONUtils
JSONUtils工具类，可用于方便的向Json中读取和写入相关类型数据，如：
String getString(JSONObject jsonObject, String key, String defaultValue) 得到string类型value
String getString(String jsonData, String key, String defaultValue) 得到string类型value
表示从json中读取某个String类型key的值
getMap(JSONObject jsonObject, String key) 得到map
getMap(String jsonData, String key) 得到map
表示从json中读取某个Map类型key的值
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
/**
* Json Utils
*/
public class JSONUtils {
public static boolean isPrintException = true;
private JSONUtils() {
throw new AssertionError();
}
/**
* get Long from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getLong(String)} exception, return defaultValue</li>
* <li>return {@link JSONObject#getLong(String)}</li>
* </ul>
*/
public static Long getLong(JSONObject jsonObject, String key, Long defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getLong(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get Long from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getLong(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static Long getLong(String jsonData, String key, Long defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getLong(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* @param jsonObject
* @param key
* @param defaultValue
* @return
* @see JSONUtils#getLong(JSONObject, String, Long)
*/
public static long getLong(JSONObject jsonObject, String key, long defaultValue) {
return getLong(jsonObject, key, (Long)defaultValue);
}
/**
* @param jsonData
* @param key
* @param defaultValue
* @return
* @see JSONUtils#getLong(String, String, Long)
*/
public static long getLong(String jsonData, String key, long defaultValue) {
return getLong(jsonData, key, (Long)defaultValue);
}
/**
* get Int from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getInt(String)} exception, return defaultValue</li>
* <li>return {@link JSONObject#getInt(String)}</li>
* </ul>
*/
public static Integer getInt(JSONObject jsonObject, String key, Integer defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getInt(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get Int from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getInt(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static Integer getInt(String jsonData, String key, Integer defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getInt(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* @param jsonObject
* @param key
* @param defaultValue
* @return
* @see JSONUtils#getInt(JSONObject, String, Integer)
*/
public static int getInt(JSONObject jsonObject, String key, int defaultValue) {
return getInt(jsonObject, key, (Integer)defaultValue);
}
/**
* @param jsonObject
* @param key
* @param defaultValue
* @return
* @see JSONUtils#getInt(String, String, Integer)
*/
public static int getInt(String jsonData, String key, int defaultValue) {
return getInt(jsonData, key, (Integer)defaultValue);
}
/**
* get Double from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getDouble(String)} exception, return defaultValue</li>
* <li>return {@link JSONObject#getDouble(String)}</li>
* </ul>
*/
public static Double getDouble(JSONObject jsonObject, String key, Double defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getDouble(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get Double from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getDouble(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static Double getDouble(String jsonData, String key, Double defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getDouble(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* @param jsonObject
* @param key
* @param defaultValue
* @return
* @see JSONUtils#getDouble(JSONObject, String, Double)
*/
public static double getDouble(JSONObject jsonObject, String key, double defaultValue) {
return getDouble(jsonObject, key, (Double)defaultValue);
}
/**
* @param jsonObject
* @param key
* @param defaultValue
* @return
* @see JSONUtils#getDouble(String, String, Double)
*/
public static double getDouble(String jsonData, String key, double defaultValue) {
return getDouble(jsonData, key, (Double)defaultValue);
}
/**
* get String from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getString(String)} exception, return defaultValue</li>
* <li>return {@link JSONObject#getString(String)}</li>
* </ul>
*/
public static String getString(JSONObject jsonObject, String key, String defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getString(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get String from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getString(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static String getString(String jsonData, String key, String defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getString(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get String from jsonObject
*
* @param jsonObject
* @param defaultValue
* @param keyArray
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if keyArray is null or empty, return defaultValue</li>
* <li>get {@link #getJSONObject(JSONObject, String, JSONObject)} by recursion, return it. if anyone is
* null, return directly</li>
* </ul>
*/
public static String getStringCascade(JSONObject jsonObject, String defaultValue, String... keyArray) {
if (jsonObject == null || ArrayUtils.isEmpty(keyArray)) {
return defaultValue;
}
String data = jsonObject.toString();
for (String key : keyArray) {
data = getStringCascade(data, key, defaultValue);
if (data == null) {
return defaultValue;
}
}
return data;
}
/**
* get String from jsonData
*
* @param jsonData
* @param defaultValue
* @param keyArray
* @return <ul>
* <li>if jsonData is null, return defaultValue</li>
* <li>if keyArray is null or empty, return defaultValue</li>
* <li>get {@link #getJSONObject(JSONObject, String, JSONObject)} by recursion, return it. if anyone is
* null, return directly</li>
* </ul>
*/
public static String getStringCascade(String jsonData, String defaultValue, String... keyArray) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
String data = jsonData;
for (String key : keyArray) {
data = getString(data, key, defaultValue);
if (data == null) {
return defaultValue;
}
}
return data;
}
/**
* get String array from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getJSONArray(String)} exception, return defaultValue</li>
* <li>if {@link JSONArray#getString(int)} exception, return defaultValue</li>
* <li>return string array</li>
* </ul>
*/
public static String[] getStringArray(JSONObject jsonObject, String key, String[] defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
JSONArray statusArray = jsonObject.getJSONArray(key);
if (statusArray != null) {
String[] value = new String[statusArray.length()];
for (int i = 0; i < statusArray.length(); i++) {
value[i] = statusArray.getString(i);
}
return value;
}
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
return defaultValue;
}
/**
* get String array from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getStringArray(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static String[] getStringArray(String jsonData, String key, String[] defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getStringArray(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get String list from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getJSONArray(String)} exception, return defaultValue</li>
* <li>if {@link JSONArray#getString(int)} exception, return defaultValue</li>
* <li>return string array</li>
* </ul>
*/
public static List<String> getStringList(JSONObject jsonObject, String key, List<String> defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
JSONArray statusArray = jsonObject.getJSONArray(key);
if (statusArray != null) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < statusArray.length(); i++) {
list.add(statusArray.getString(i));
}
return list;
}
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
return defaultValue;
}
/**
* get String list from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getStringList(JSONObject, String, List)}</li>
* </ul>
*/
public static List<String> getStringList(String jsonData, String key, List<String> defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getStringList(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get JSONObject from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getJSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONObject#getJSONObject(String)}</li>
* </ul>
*/
public static JSONObject getJSONObject(JSONObject jsonObject, String key, JSONObject defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getJSONObject(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get JSONObject from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonData is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getJSONObject(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static JSONObject getJSONObject(String jsonData, String key, JSONObject defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getJSONObject(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get JSONObject from jsonObject
*
* @param jsonObject
* @param defaultValue
* @param keyArray
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if keyArray is null or empty, return defaultValue</li>
* <li>get {@link #getJSONObject(JSONObject, String, JSONObject)} by recursion, return it. if anyone is
* null, return directly</li>
* </ul>
*/
public static JSONObject getJSONObjectCascade(JSONObject jsonObject, JSONObject defaultValue, String... keyArray) {
if (jsonObject == null || ArrayUtils.isEmpty(keyArray)) {
return defaultValue;
}
JSONObject js = jsonObject;
for (String key : keyArray) {
js = getJSONObject(js, key, defaultValue);
if (js == null) {
return defaultValue;
}
}
return js;
}
/**
* get JSONObject from jsonData
*
* @param jsonData
* @param defaultValue
* @param keyArray
* @return <ul>
* <li>if jsonData is null, return defaultValue</li>
* <li>if keyArray is null or empty, return defaultValue</li>
* <li>get {@link #getJSONObject(JSONObject, String, JSONObject)} by recursion, return it. if anyone is
* null, return directly</li>
* </ul>
*/
public static JSONObject getJSONObjectCascade(String jsonData, JSONObject defaultValue, String... keyArray) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getJSONObjectCascade(jsonObject, defaultValue, keyArray);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get JSONArray from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>if {@link JSONObject#getJSONArray(String)} exception, return defaultValue</li>
* <li>return {@link JSONObject#getJSONArray(String)}</li>
* </ul>
*/
public static JSONArray getJSONArray(JSONObject jsonObject, String key, JSONArray defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getJSONArray(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get JSONArray from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getJSONArray(JSONObject, String, JSONObject)}</li>
* </ul>
*/
public static JSONArray getJSONArray(String jsonData, String key, JSONArray defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getJSONArray(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get Boolean from jsonObject
*
* @param jsonObject
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if key is null or empty, return defaultValue</li>
* <li>return {@link JSONObject#getBoolean(String)}</li>
* </ul>
*/
public static boolean getBoolean(JSONObject jsonObject, String key, Boolean defaultValue) {
if (jsonObject == null || StringUtils.isEmpty(key)) {
return defaultValue;
}
try {
return jsonObject.getBoolean(key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get Boolean from jsonData
*
* @param jsonData
* @param key
* @param defaultValue
* @return <ul>
* <li>if jsonObject is null, return defaultValue</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return defaultValue</li>
* <li>return {@link JSONUtils#getBoolean(JSONObject, String, Boolean)}</li>
* </ul>
*/
public static boolean getBoolean(String jsonData, String key, Boolean defaultValue) {
if (StringUtils.isEmpty(jsonData)) {
return defaultValue;
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getBoolean(jsonObject, key, defaultValue);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return defaultValue;
}
}
/**
* get map from jsonObject.
*
* @param jsonObject key-value pairs json
* @param key
* @return <ul>
* <li>if jsonObject is null, return null</li>
* <li>return {@link JSONUtils#parseKeyAndValueToMap(String)}</li>
* </ul>
*/
public static Map<String, String> getMap(JSONObject jsonObject, String key) {
return JSONUtils.parseKeyAndValueToMap(JSONUtils.getString(jsonObject, key, null));
}
/**
* get map from jsonData.
*
* @param jsonData key-value pairs string
* @param key
* @return <ul>
* <li>if jsonData is null, return null</li>
* <li>if jsonData length is 0, return empty map</li>
* <li>if jsonData {@link JSONObject#JSONObject(String)} exception, return null</li>
* <li>return {@link JSONUtils#getMap(JSONObject, String)}</li>
* </ul>
*/
public static Map<String, String> getMap(String jsonData, String key) {
if (jsonData == null) {
return null;
}
if (jsonData.length() == 0) {
return new HashMap<String, String>();
}
try {
JSONObject jsonObject = new JSONObject(jsonData);
return getMap(jsonObject, key);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return null;
}
}
/**
* parse key-value pairs to map. ignore empty key, if getValue exception, put empty value
*
* @param sourceObj key-value pairs json
* @return <ul>
* <li>if sourceObj is null, return null</li>
* <li>else parse entry by {@link MapUtils#putMapNotEmptyKey(Map, String, String)} one by one</li>
* </ul>
*/
@SuppressWarnings("rawtypes")
public static Map<String, String> parseKeyAndValueToMap(JSONObject sourceObj) {
if (sourceObj == null) {
return null;
}
Map<String, String> keyAndValueMap = new HashMap<String, String>();
for (Iterator iter = sourceObj.keys(); iter.hasNext();) {
String key = (String)iter.next();
MapUtils.putMapNotEmptyKey(keyAndValueMap, key, getString(sourceObj, key, ""));
}
return keyAndValueMap;
}
/**
* parse key-value pairs to map. ignore empty key, if getValue exception, put empty value
*
* @param source key-value pairs json
* @return <ul>
* <li>if source is null or source's length is 0, return empty map</li>
* <li>if source {@link JSONObject#JSONObject(String)} exception, return null</li>
* <li>return {@link JSONUtils#parseKeyAndValueToMap(JSONObject)}</li>
* </ul>
*/
public static Map<String, String> parseKeyAndValueToMap(String source) {
if (StringUtils.isEmpty(source)) {
return null;
}
try {
JSONObject jsonObject = new JSONObject(source);
return parseKeyAndValueToMap(jsonObject);
} catch (JSONException e) {
if (isPrintException) {
e.printStackTrace();
}
return null;
}
}
} 
8468
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
