package com.sohu.cache.util;
import static com.sohu.cache.constant.EmptyObjectConstant.EMPTY_STRING;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.sohu.cache.constant.BaseConstant;
import com.sohu.cache.constant.EmptyObjectConstant;
/**
* Description: String Utils
*
* @author nileader / nileader@gmail.com
* @Date Feb 10, 2012
*/
public class StringUtil {
/**
* Check String is equals. targetStr compare with compareStrArray, and
* return true if equals one or more
*
* @param targetStr
* 寰呮瘮杈冪殑瀛楃涓�
* @param compareStrArray
* 瑕佹瘮杈冪殑涓�釜鎴栧涓瓧绗︿覆鏍囧噯
* @return
*/
public static boolean containsIgnoreCase( final String originalStr, final CharSequence targetStr ) {
if ( null == originalStr ) {
return false;
}
String originalStrCaps = originalStr.toUpperCase();
String targetStrCaps = targetStr.toString().toUpperCase();
return originalStrCaps.contains( targetStrCaps );
}
/**
* Description: Remove {_, -, @, $, #, /, &} in string and make letter after
* this uppercase.<br>
* e.g. ni_lea-der@gmail./com -> niLeaDerGmail.Com
*
* @param @param inputString
* @param @param firstCharacterUppercase The first letter is need uppercase.
* @return String
* @throws
*/
public static String convertToCamelCaseString( String inputString, boolean firstCharacterUppercase ) {
if ( null == inputString ) {
return null;
}
StringBuilder sb = new StringBuilder();
boolean nextUpperCase = false;
for ( int i = 0; i < inputString.length(); i++ ) {
char c = inputString.charAt( i );
switch ( c ) {
case '_':
case '-':
case '@':
case '$':
case '#':
case ' ':
case '/':
case '&':
if ( sb.length() > 0 ) {
nextUpperCase = true;
}
break;
default:
if ( nextUpperCase ) {
sb.append( Character.toUpperCase( c ) );
nextUpperCase = false;
} else {
sb.append( c );
}
break;
}
}
if ( firstCharacterUppercase ) {
sb.setCharAt( 0, Character.toUpperCase( sb.charAt( 0 ) ) );
} else {
sb.setCharAt( 0, Character.toLowerCase( sb.charAt( 0 ) ) );
}
return sb.toString();
}
/**
* Return Default if originalStr is empty.
*
* @param originalStr
* 寰呯‘璁ゅ�
* @param defaultStr
* 榛樿鍊�
* @return 濡傛灉originalStr涓虹┖锛岄偅涔堝氨杩斿洖defaultStr
*/
public static String defaultIfBlank( String originalStr, String defaultStr ) {
if ( StringUtil.isBlank( originalStr ) ) {
return defaultStr;
}
Collections.emptyList();
return originalStr;
}
/**
* Check String is equals Ignore Case. targetStr compare with
* compareStrArray, and return true if equals all
*
* @param targetStr
* 寰呮瘮杈冪殑瀛楃涓�
* @param compareStrArray
* 瑕佹瘮杈冪殑涓�釜鎴栧涓瓧绗︿覆鏍囧噯
* @return true if targetStr same with every string in compareStrArray
*/
public static boolean equalsIgnoreCaseAll( String targetStr, String... compareStrArray ) {
if ( StringUtil.isBlank( targetStr ) || null == compareStrArray || 0 == compareStrArray.length ) {
return false;
}
for ( int i = 0; i < compareStrArray.length; i++ ) {
if ( !targetStr.equalsIgnoreCase( compareStrArray[i] ) ) {
return false;
}
}
return true;
}
/**
* Check String is equals. targetStr compare with compareStrArray, and
* return true if equals one or more
*
* @param targetStr
* 寰呮瘮杈冪殑瀛楃涓�
* @param compareStrArray
* 瑕佹瘮杈冪殑涓�釜鎴栧涓瓧绗︿覆鏍囧噯
* @return true if targetStr same with string in compareStrArray one at
* least
*/
public static boolean equalsIgnoreCaseOne( String targetStr, String... compareStrArray ) {
if ( StringUtil.isBlank( targetStr ) || null == compareStrArray || 0 == compareStrArray.length ) {
return false;
}
for ( int i = 0; i < compareStrArray.length; i++ ) {
if ( targetStr.equalsIgnoreCase( compareStrArray[i] ) ) {
return true;
}
}
return false;
}
/**
* 閫氳繃姝ｅ垯琛ㄨ揪鏂瑰紡锛屾壘鍑轰竴涓瓧绗︿覆涓墍鏈夋寚瀹氱殑瀛愪覆
*
* @param @param originalStr 瀛楃涓�
* @param @param regex 寰呮煡鎵惧瓙涓茬殑姝ｅ垯琛ㄨ揪寮�
* @return List<String> 瀛愪覆闆嗗悎
*
* <pre>
* 瀵�/1.1.1.1:sid=0x2337c7074dofj02e,37775[1](queued=0,recved=6,sent=7,sid=0x2337c7074f1102e,sdlfjle,dsfe鐨勭粨鏋滄槸锛�
* [sid=0x2337c7074dofj02e, , sid=0x2337c7074f1102e, ]
* </pre>
*/
public static List< String > findAllByRegex( String originalStr, String regex ) {
if ( StringUtil.isBlank( originalStr ) || StringUtil.isBlank( regex ) )
return null;
List< String > targetStrList = new ArrayList< String >();
final Pattern patternOfTargetStr = Pattern.compile( regex, Pattern.CANON_EQ );
final Matcher matcherOfTargetStr = patternOfTargetStr.matcher( originalStr );
/** 寮�瑙ｆ瀽 */
while ( matcherOfTargetStr.find() ) {
targetStrList.add( StringUtil.trimToEmpty( matcherOfTargetStr.group() ) );
}
return targetStrList;
}
/**
* 閫氳繃姝ｅ垯琛ㄨ揪鏂瑰紡锛屾壘鍑轰竴涓瓧绗︿覆涓涓�釜鎸囧畾鐨勫瓙涓�
*
* @param @param originalStr 瀛楃涓�
* @param @param regex 寰呮煡鎵惧瓙涓茬殑姝ｅ垯琛ㄨ揪寮�
* @return List<String> 瀛愪覆闆嗗悎
*
* <pre>
* 瀵�/1.1.1.1:sid=0x2337c7074dofj02e,37775[1](queued=0,recved=6,sent=7,sid=0x2337c7074f1102e,sdlfjle,dsfe鐨勭粨鏋滄槸锛�
* sid=0x2337c7074dofj02e,
* </pre>
*/
public static String findFirstByRegex( String originalStr, String regex ) {
if ( StringUtil.isBlank( originalStr ) || StringUtil.isBlank( regex ) )
return EMPTY_STRING;
final Pattern patternOfTargetStr = Pattern.compile( regex, Pattern.CANON_EQ );
final Matcher matcherOfTargetStr = patternOfTargetStr.matcher( originalStr );
/** 寮�瑙ｆ瀽 */
if ( matcherOfTargetStr.find() ) {
return StringUtil.trimToEmpty( matcherOfTargetStr.group() );
}
return EMPTY_STRING;
}
/**
* 鐢熸垚绌虹櫧琛�
*
* @param lines
* 琛屾暟
*/
public static String generateLineBlank( int lines ) {
StringBuilder sb = new StringBuilder();
for ( int i = 0; i < lines; i++ ) {
sb.append( "\n" );
}
return sb.toString();
}
/**
* make first letter lower case for str
*
* @return Same letter, but the first letter is lower case.
*/
public static String makeFirstLetterLowerCase( String str ) {
String firstLetter = str.substring( 0, 1 );
return firstLetter.toLowerCase() + str.substring( 1, str.length() );
}
/***
* check if orginalStr is null or empty. <br>
* If have more than one originalStr, use isBlank(String...
* originalStrArray)
*
* @param originalStr
* 寰呯‘璁ゅ�
* @return true or false;
*/
public static boolean isBlank( String originalStr ) {
if ( null == originalStr ) {
return true;
}
if ( originalStr.contains( BaseConstant.WORD_SEPARATOR ) ) {
return false;
}
return trimToEmpty( originalStr ).isEmpty();
}
/***
* check if orginalStr is null or empty
*
* @param String
* ... originalStrArray
* @return true if have one blank at least.
*/
public static boolean isBlank( String... originalStrArray ) {
if ( null == originalStrArray || 0 == originalStrArray.length )
return true;
for ( int i = 0; i < originalStrArray.length; i++ ) {
if ( isBlank( originalStrArray[i] ) )
return true;
}
return false;
}
/**
* check the originalStr is contain the whitespace
*
* @param originalStr
* @return true if contain whitespace
*/
public static boolean isContainWhitespace( String originalStr ) {
if ( StringUtil.isBlank( originalStr ) ) {
return true;
}
int strLen = originalStr.length();
for ( int i = 0; i < strLen; i++ ) {
char ch = originalStr.charAt( i );
if ( Character.isWhitespace( ch ) ) {
return true;
}
}
return false;
}
/**
* 字符串连接，使用指定分隔符
*
* @param subStr
* @return
*/
public static String join( String... subStrs ) {
if ( null == subStrs || 0 == subStrs.length ) {
return EMPTY_STRING;
}
StringBuilder sb = new StringBuilder();
for ( String subStr : subStrs ) {
sb.append( subStr ).append( BaseConstant.WORD_SEPARATOR );
}
String sbStr = sb.toString();
if ( sbStr.endsWith( BaseConstant.WORD_SEPARATOR ) ) {
sbStr = StringUtil.replaceLast( sbStr, BaseConstant.WORD_SEPARATOR, "" );
}
return sbStr;
}
/**
* Description: Replaces last substring of this string that matches the
* given regular expression with the given replacement.<br>
* Do not worry about null pointer
*
* @param @param regex
* @param @param replacement
* @return String
* @throws
*/
public static String replaceAll( String originalStr, String replacement, String regex ) {
return StringUtil.trimToEmpty( originalStr ).replaceAll( regex, replacement );
}
public static String replaceAll( String originalStr, String replacement, String... regexArray ) {
if ( 0 == regexArray.length )
return originalStr;
for ( String regex : regexArray ) {
originalStr = StringUtil.replaceAll( originalStr, replacement, regex );
}
return originalStr;
}
/**
* Description: Replaces last substring of this string that matches the
* given regular expression with the given replacement.
*
* @param @param regex
* @param @param replacement
* @param @return
* @return String
* @throws
*/
public static String replaceLast( String originalStr, String regex, String replacement ) {
if ( StringUtil.isBlank( originalStr ) )
return EMPTY_STRING;
int index = originalStr.lastIndexOf( regex );
if ( -1 == index )
return originalStr;
// 鍏堝瓨鍌ㄨ繖涓猧ndex涔嬪墠鐨勬墍鏈塻tr
String temp = originalStr.substring( 0, index );
String temp2 = originalStr.substring( index, originalStr.length() );
temp2 = temp2.replaceFirst( regex, replacement );
originalStr = temp + temp2;
return originalStr;
}
/**
* Description: Replaces all {n} placeholder use params
*
* @param originalStr
* a string such as :
* "select * from table where id={0}, name={1}, gender={3}"
* @param replacementParams
* real params: 1,yinshi.nc,male
* @note n start with 0
*/
public static String replaceSequenced( String originalStr, Object... replacementParams ) {
if ( StringUtil.isBlank( originalStr ) )
return EMPTY_STRING;
if ( null == replacementParams || 0 == replacementParams.length )
return originalStr;
for ( int i = 0; i < replacementParams.length; i++ ) {
String elementOfParams = replacementParams[i] + EmptyObjectConstant.EMPTY_STRING;
if ( StringUtil.trimToEmpty( elementOfParams ).equalsIgnoreCase( "null" ) )
elementOfParams = EmptyObjectConstant.EMPTY_STRING;
originalStr = originalStr.replace( "{" + i + "}", StringUtil.trimToEmpty( elementOfParams ) );
}
return originalStr;
}
/**
* 璁剧疆鍓嶇紑锛屽鏋滆繖涓瓧绗︿覆宸茬粡鏄繖涓墠缂�簡锛岄偅涔堝氨涓嶄綔浠讳綍鎿嶄綔銆� TODO none test
* */
public static String setPrefix( String originalStr, String prefix ) {
originalStr = StringUtil.trimToEmpty( originalStr );
prefix = StringUtil.trimToEmpty( prefix );
if ( !originalStr.startsWith( prefix ) ) {
originalStr = prefix + originalStr;
}
return originalStr;
}
/**
/**
* 鍒ゆ柇瀛楃涓叉槸鍚﹁秴杩囨寚瀹氶暱搴︼紝濡備綍瓒呰繃锛屾坊鍔犳寚瀹氬悗缂�
*
* @param originalStr
* "閾舵椂鐨�
* @param maxLength
* 2
* @param suffix
* ...
* @return "閾舵椂..."
*/
public static String subStringIfTooLong( String originalStr, int maxLength, String suffix ) {
if ( StringUtil.isBlank( originalStr ) )
return EmptyObjectConstant.EMPTY_STRING;
if ( maxLength < 0 )
maxLength = 0;
if ( originalStr.length() > maxLength )
return originalStr.substring( 0, maxLength ) + StringUtil.trimToEmpty( suffix );
return originalStr;
}
/**
* Returns a copy of the string, with leading and trailing whitespace
* omitted. Don't worry the NullPointerException. Will never return Null.
*
* @param originalStr
* @return "" or String without empty str.
*/
public static String trimToEmpty( String originalStr ) {
if ( null == originalStr || originalStr.isEmpty() )
return EMPTY_STRING;
if ( originalStr.equals( BaseConstant.WORD_SEPARATOR ) )
return originalStr;
return originalStr.trim();
}
/**
* URL编码
*
* @param s
* String to be translated.
* @param enc
* The name of a supported character encoding.
* @return
*/
public static String urlEncode( String s, String enc ) {
if ( StringUtil.isBlank( s ) )
return StringUtil.trimToEmpty( s );
try {
return java.net.URLEncoder.encode( trimToEmpty( s ), enc );
} catch ( UnsupportedEncodingException e ) {
return s;
}
}
/**
* URL编码,使用UTF-8编码
*
* @param s
* String to be translated.
* @param enc
* The name of a supported character encoding.
* @return
*/
public static String urlEncode( String s ) {
if ( StringUtil.isBlank( s ) )
return StringUtil.trimToEmpty( s );
return urlEncode( trimToEmpty( s ), "UTF-8" );
}
}