Java tutorial
/** * Copyright (c) 2012-2014 http://www.eryansky.com * * Licensed under the Apache License, Version 2.0 (the "License"); */ package com.eryansky.common.utils; import java.io.UnsupportedEncodingException; import java.net.URLEncoder; import java.sql.Timestamp; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.Random; import java.util.regex.Matcher; import java.util.regex.Pattern; import com.eryansky.common.utils.collections.MapUtils; /** * ? * @author &Eryan eryanwcp@gmail.com * @date 2012-1-9?2:43:26 */ public class StringUtils extends org.apache.commons.lang3.StringUtils { 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"; public static final String defaultKeyAndValueSeparator = ":"; public static final String defaultValueEntitySeparator = ","; public static final String defaultKeyOrValueQuote = "\""; /** * ?0 * * @param str * @return null0, true; ?false. * * <pre> * isEmpty(null) = true; * isEmpty("") = true; * isEmpty(" ") = false; * </pre> */ public static boolean isEmpty(String str) { return (str == null || str.length() == 0); } /** * ?0? * * @param str * @return null0?, true; ?false. * * <pre> * isBlank(null) = true; * isBlank("") = true; * isBlank(" ") = true; * isBlank("a") = false; * isBlank("a ") = false; * isBlank(" a") = false; * isBlank("a b") = false; * </pre> */ public static boolean isBlank(String str) { return (isEmpty(str) || (str.trim().length() == 0)); } /** * ?? * * @param str * @return ?? * * <pre> * capitalizeFirstLetter(null) = null; * capitalizeFirstLetter("") = ""; * capitalizeFirstLetter("1ab") = "1ab" * capitalizeFirstLetter("a") = "A" * capitalizeFirstLetter("ab") = "Ab" * capitalizeFirstLetter("Abc") = "Abc" * </pre> */ public static String capitalizeFirstLetter(String str) { return (isEmpty(str) || !Character.isLetter(str.charAt(0))) ? str : Character.toUpperCase(str.charAt(0)) + str.substring(1); } /** * ?utf8? * * @param str * @return ???null * * <pre> * utf8Encode(null) = null * utf8Encode("") = ""; * utf8Encode("aa") = "aa"; * utf8Encode("") = "??"; * </pre> */ public static String utf8Encode(String str) { if (!isEmpty(str) && str.getBytes().length != str.length()) { try { return URLEncoder.encode(str, "UTF-8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); return null; } } return str; } /** * ?utf8??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; } /** * null?0 * * @param str ? * @return * @see * <pre> * nullStrToEmpty(null) = ""; * nullStrToEmpty("") = ""; * nullStrToEmpty("aa") = ""; * </pre> */ public static String nullStrToEmpty(String str) { return (str == null ? "" : str); } /** * ?? * * @param format ??format"yyyy-MM-dd HH:mm:ss" * @return format??"yyyy-MM-dd HH:mm:ss" * * <pre> * currentDate(null) = "yyyy-MM-dd HH:mm:ss" * currentDate("") = "yyyy-MM-dd HH:mm:ss" * currentDate(" ") = "yyyy-MM-dd HH:mm:ss" * currentDate("yyyy-MM-dd") = "yyyy-MM-dd" * currentDate("yyyy/MM/dd HH:mm:ss") = "yyyy/MM/dd HH:mm:ss" * </pre> */ public static String currentDate(String format) { SimpleDateFormat dateFormat = new SimpleDateFormat(isBlank(format) ? "yyyy-MM-dd HH:mm:ss" : format); return dateFormat.format(new Date()); } /** * "yyyy-MM-dd HH:mm:ss"?? * * @return "yyyy-MM-dd HH:mm:ss" */ public static String currentDate() { return currentDate(""); } /** * ??? * * @param format ??format"yyyy-MM-dd HH:mm:ss SS" * @return format??"yyyy-MM-dd HH:mm:ss SS" * * <pre> * currentDate(null) = "yyyy-MM-dd HH:mm:ss SS" * currentDate("") = "yyyy-MM-dd HH:mm:ss SS" * currentDate(" ") = "yyyy-MM-dd HH:mm:ss SS" * currentDate("yyyy-MM-dd") = "yyyy-MM-dd" * currentDate("yyyy/MM/dd HH:mm:ss SS") = "yyyy/MM/dd HH:mm:ss SS" * </pre> */ public static String currentDateInMills(String format) { SimpleDateFormat dateFormat = new SimpleDateFormat(isBlank(format) ? "yyyy-MM-dd HH-mm-ss SS" : format); return dateFormat.format(new Timestamp(System.currentTimeMillis())); } /** * "yyyy-MM-dd HH:mm:ss SS"?? * * @return "yyyy-MM-dd HH:mm:ss SS" */ public static String currentDateInMills() { return currentDateInMills(""); } /** * ??? * * @param time * @return */ @SuppressWarnings("deprecation") public static String processTime(Long time) { long oneDay = 24 * 60 * 60 * 1000; Date now = new Date(); Date orginalTime = new Date(time); long nowDay = now.getTime() - (now.getHours() * 3600 + now.getMinutes() * 60 + now.getSeconds()) * 1000; long yesterday = nowDay - oneDay; String nowHourAndMinute = toDoubleDigit(orginalTime.getHours()) + ":" + toDoubleDigit(orginalTime.getMinutes()); if (time >= now.getTime()) { return ""; } else if ((now.getTime() - time) < (60 * 1000)) { return (now.getTime() - time) / 1000 + "? " + nowHourAndMinute + " "; } else if ((now.getTime() - time) < (60 * 60 * 1000)) { return (now.getTime() - time) / 1000 / 60 + "? " + nowHourAndMinute + " "; } else if ((now.getTime() - time) < (24 * 60 * 60 * 1000)) { return (now.getTime() - time) / 1000 / 60 / 60 + "?? " + nowHourAndMinute + " "; } else if (time >= nowDay) { return " " + nowHourAndMinute; } else if (time >= yesterday) { return " " + nowHourAndMinute; } else { return toDoubleDigit(orginalTime.getMonth()) + "-" + toDoubleDigit(orginalTime.getDate()) + " " + nowHourAndMinute + ":" + toDoubleDigit(orginalTime.getSeconds()); } } /** * ????0??? * * @param number * @return */ public static String toDoubleDigit(int number) { if (number >= 0 && number < 10) { return "0" + ((Integer) number).toString(); } return ((Integer) number).toString(); } /** * hrefinnerHtml * * @param href href * @return hrefinnerHtml * <ul> * <li>""</li> * <li>???</li> * <li>???innerHtml</li> * </ul> * @see * <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> */ public static String getHrefInnerHtml(String href) { if (isEmpty(href)) { return ""; } // String hrefReg = "[^(<a)]*<[\\s]*a[\\s]*[^(a>)]*>(.+?)<[\\s]*/a[\\s]*>.*"; 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; } /** * ???? * * @param length * @return * @see ?{@link StringUtils#getRandom(String source, int length)} */ public static String getRandomNumbersAndLetters(int length) { return getRandom(NUMBERS_AND_LETTERS, length); } /** * ??? * * @param length * @return * @see ?{@link StringUtils#getRandom(String source, int length)} */ public static String getRandomNumbers(int length) { return getRandom(NUMBERS, length); } /** * ???? * * @param length * @return * @see ?{@link StringUtils#getRandom(String source, int length)} */ public static String getRandomLetters(int length) { return getRandom(LETTERS, length); } /** * ???? * * @param length * @return * @see ?{@link StringUtils#getRandom(String source, int length)} */ public static String getRandomCapitalLetters(int length) { return getRandom(CAPITAL_LETTERS, length); } /** * ????? * * @param length * @return * @see ?{@link StringUtils#getRandom(String source, int length)} */ public static String getRandomLowerCaseLetters(int length) { return getRandom(LOWER_CASE_LETTERS, length); } /** * ?source?? * * @param source ? * @param length * @return * <ul> * <li>sourcenullnull</li> * <li>??{@link StringUtils#getRandom(char[] sourceChar, int length)}</li> * </ul> */ public static String getRandom(String source, int length) { return StringUtils.isEmpty(source) ? null : getRandom(source.toCharArray(), length); } /** * ?sourceChar?? * * @param sourceChar ? * @param length * @return * <ul> * <li>sourceCharnull0null</li> * <li>length?0null</li> * </ul> */ public static String getRandom(char[] sourceChar, int length) { if (sourceChar == null || sourceChar.length == 0 || length < 0) { return null; } StringBuilder str = new StringBuilder(""); Random random = new Random(); for (int i = 0; i < length; i++) { str.append(sourceChar[random.nextInt(sourceChar.length)]); } return str.toString(); } /** * html?? * * @param source * @return */ public static String htmlEscapeCharsToString(String source) { if (StringUtils.isEmpty(source)) { return ""; } else { return source.replaceAll("<", "<").replaceAll(">", ">").replaceAll("&", "&") .replaceAll(""", "\""); } } /** * String * * @param actual * @param expected * @return * <ul> * <li>nulltrue</li> * <li>?nulltrue</li> * <li>?false</li> * </ul> */ public static boolean isEquals(String actual, String expected) { return ObjectUtils.isEquals(actual, expected); } /** * keyvalue??mapkeyvaluekey * * @param source keyvalue * @param keyAndValueSeparator keyvalue * @param valueEntitySeparator entity * @param keyOrValueQuote keyvalue? * @return * @see * <ul> * <li>parseKeyAndValueToMap("key1:value1,key2,value2", ":", ",")={(key1, value1), (key2, value2)}</li> * <li>parseKeyAndValueToMap(" key1:value1 ,key2,value2", ":", ",")={(key1, value1), (key2, value2)}</li> * <li>parseKeyAndValueToMap(" key1: value1 ,key2,value2", ":", ",")={(key1, value1), (key2, value2)}</li> * </ul> */ public static Map<String, String> parseKeyAndValueToMap(String source, String keyAndValueSeparator, String valueEntitySeparator, String keyOrValueQuote) { if (isEmpty(source)) { return null; } if (isEmpty(keyAndValueSeparator)) { keyAndValueSeparator = defaultKeyAndValueSeparator; } if (isEmpty(valueEntitySeparator)) { valueEntitySeparator = defaultValueEntitySeparator; } if (isEmpty(keyOrValueQuote)) { keyOrValueQuote = defaultKeyOrValueQuote; } Map<String, String> keyAndValueMap = new HashMap<String, String>(); String[] keyAndValueArray = source.split(valueEntitySeparator); if (keyAndValueArray != null) { int seperator; for (String valueEntity : keyAndValueArray) { if (!isEmpty(valueEntity)) { seperator = valueEntity.indexOf(keyAndValueSeparator); if (seperator != -1 && seperator < valueEntity.length()) { MapUtils.putMapNotEmptyKey(keyAndValueMap, RemoveBothSideSymbol(valueEntity.substring(0, seperator).trim(), keyOrValueQuote), RemoveBothSideSymbol(valueEntity.substring(seperator + 1).trim(), keyOrValueQuote)); } } } } return keyAndValueMap; } /** * keyvalue??mapkeyvaluekey * * @param source keyvalue * @return * @see * <ul> * <li>?{@link StringUtils#parseKeyAndValueToMap(String, String, String, String)}</li> * </ul> */ public static Map<String, String> parseKeyAndValueToMap(String source) { return parseKeyAndValueToMap(source, defaultKeyAndValueSeparator, defaultValueEntitySeparator, defaultKeyOrValueQuote); } /** * ?? * * @param source * @param symbol ? * @return */ public static String RemoveBothSideSymbol(String source, String symbol) { if (isEmpty(source) || isEmpty(symbol)) { return source; } int firstIndex = source.indexOf(symbol); int lastIndex = source.lastIndexOf(symbol); try { return source.substring(((firstIndex == 0) ? symbol.length() : 0), ((lastIndex == source.length() - 1) ? (source.length() - symbol.length()) : source.length())); } catch (IndexOutOfBoundsException e) { return ""; } } /** * ?(?"*"?). * @param pattern ? * @param str ?? * @return */ public static boolean simpleWildcardMatch(String pattern, String str) { return wildcardMatch(pattern, str, "*"); } /** * ?. * @param pattern ? * @param str ?? * @param wildcard ? * @return */ public static boolean wildcardMatch(String pattern, String str, String wildcard) { if (StringUtils.isEmpty(pattern) || StringUtils.isEmpty(str)) { return false; } final boolean startWith = pattern.startsWith(wildcard); final boolean endWith = pattern.endsWith(wildcard); String[] array = StringUtils.split(pattern, wildcard); int currentIndex = -1; int lastIndex = -1; switch (array.length) { case 0: return true; case 1: currentIndex = str.indexOf(array[0]); if (startWith && endWith) { return currentIndex >= 0; } if (startWith) { return currentIndex + array[0].length() == str.length(); } if (endWith) { return currentIndex == 0; } return str.equals(pattern); default: for (String part : array) { currentIndex = str.indexOf(part); if (currentIndex > lastIndex) { lastIndex = currentIndex; continue; } return false; } return true; } } }