stringutil.java

用httpclient-4.0-alpha2 打造基于http协议的网站分析器

package com.ue.browser.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.net.*;

/**
 * 字符处理类
 * 
 * @author robin.hu
 * @copyright UE.com
 */
public class StringUtil {
	
	/**
	 * 把第一次出现html的字符串之前的字符串清除掉
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 清除后的字符串
	 */
	public static String SpecialString(String sourceString) {
		String w3chtml = "";
		int firstIndex = -1;
		if (sourceString == null){
			return w3chtml;
		}else{
			String regex = "(<[H|h]{1}+[T|t]{1}+[M|m]{1}+[L|l]{1})";
			Pattern p = Pattern.compile(regex);
			Matcher m = p.matcher(sourceString);  
			 while(m.find())
			 {
				 firstIndex = sourceString.indexOf("<html");
				 if(firstIndex<0){
					 firstIndex = sourceString.indexOf("<HTML");
				 }
				 if(firstIndex<0){
					 firstIndex = sourceString.indexOf("<Html");
				 }
				 
			 }
			//System.out.println(firstIndex);
			if(firstIndex>=0){
				w3chtml = sourceString.substring(firstIndex);
			}
		}
		return w3chtml; 
	}
	
	/**
	 * 获取此URL的协议名称
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 处理后的字符串
	 */
	public static String getProtocol(String url) {
		String result = "";
		if (url == null){
			return result;
		}else{
			try{
				 URL myURL=new URL(url);
				 result = myURL.getProtocol();
				 }catch (MalformedURLException e){
					 e.printStackTrace();
				 }
		}
		return result; 
	}
	
	/**
	 * 从访问的URL中获取网站的域名
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 处理后的字符串
	 */
	public static String getDomain(String sourceString) {
		String result = "";
		if (sourceString == null){
			return result;
		}else{
			String[] domains = sourceString.split("/");
			result = domains[0] + "//" + domains[1] + domains[2];
		}
		return result; 
	}
	
	/**
	 * 从访问的URL中获取该URL的根目录
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 处理后的字符串
	 */
	public static String getLastPath(String sourceString) {
		String result = "";
		String[] domains;
		if (sourceString == null){
			return result;
		}else{
			domains = sourceString.split("/");
			result = domains[0]+"//"+domains[1]+domains[2];
		}
		for(int i = 3;i < domains.length-1;i++){
			result +="/" + domains[i];
			}
		return result; 
	}
	
	public static String getTruePath(String sourceString,int n) {
		String result = "";
		String[] domains;
		if (sourceString == null){
			return result;
		}else{
			domains = sourceString.split("/");
			result = domains[0]+"//"+domains[1]+domains[2];
		}
		for(int i = 3;i < domains.length-1-n;i++){
			result +="/" + domains[i];
			}
		return result; 
	}
	
	public static String getAppath(String sourceString) {
		String result = "";
		String[] domains;
		if (sourceString == null){
			return result;
		}
		domains = sourceString.split("[..]{2}+[^.]");
		int i = domains.length;
		result = domains[i-1];
			
		return result; 
	}
	
	/**
	 * 判断字符串是否以字母和数字开始
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 处理后的结果
	 */
	public static Boolean isLetterOrNumberStart(String sourceString) {
		Boolean result = false;
		String regex = "^[a-zA-Z_0-9]";
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(sourceString);
		if (m.find()){
			result = true;
		}else{
			result = false;
		}
		return result; 
	}
	
	/**
	 * 判断字符串是否以一个"/"开始且紧跟后面一个不能也为"/"
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 处理后的结果
	 */
	public static Boolean isSlashStart(String sourceString) {
		Boolean result = false;
		String regex = "^[/]{1}+[^/]";
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(sourceString);
		if (m.find()){
			result = true;
		}else{
			result = false;
		}
		return result; 
	}
	
	/**
	 * 判断字符串"js"结尾
	 * 
	 * @param sourceString
	 *            源字符串
	 * @return 处理后的结果
	 */
	public static Boolean isJsFile(String sourceString) {
		Boolean result = false;
		int len = sourceString.length();
		if ("js".equals(sourceString.substring(len-2, len))){
			result = true;
		}else{
			result = false;
		}
		return result; 
	}	
	
	public static int DoubleDotNum(String url){
		int num = 0;
		String[] ads=url.split("[..]{2}+[^.]");
		int len = ads.length;
		if(len>0) num=len-1; 
		return num;
	}
	
	
	
	/**
	 * 把空值转换为空字符串
	 * 
	 * @param srcString
	 *            源字符串
	 * @return 非null字符串
	 */
	public static String nullToString(String srcString) {
		if (srcString == null)
			return new String("");
		else
			return srcString;
	}
	
	/**
	 * @param value
	 * @param len 
	 * @return String
	 */
	public static String limitString(String value){
		if (value == null) value = "";
		String v1 = "";
		int l = value.length();
		if (l > 6){
			v1 = value.substring(0, 5) + "***";
			if (l > 9) v1 += value.substring(9);
		}
		else{
			v1 = value;
		}
		return v1;
	}
	
	/**
	 * 将UNICODE转化为utf-8编码(&#xxxx)
	 * 
	 * @param srcString
	 *            源字符串
	 * 
	 * @return String UTF8标记字符串
	 */
	public static String toUTF8(String srcString) {
		char temChr;
		int ascChr;
		String rtStr = new String("");
		if (srcString == null)
			srcString = "";
		for (int i = 0; i < srcString.length(); i++) {
			temChr = srcString.charAt(i);
			ascChr = temChr + 0;
			rtStr += "&#x" + Integer.toHexString(ascChr) + ";";
		}
		return rtStr;
	}

	/**
	 * 把空值替换为指定字符串
	 * 
	 * @param srcString
	 *            源字符串
	 * @param toString
	 *            用于替换的字符串
	 * @return 非null字符串
	 */
	public static String nullToString(String srcString, String toString) {
		if (srcString == null)
			return toString;
		else
			return srcString;
	}

	/**
	 * 把字符创转换为布尔类型，默认返回defaultValue
	 * 
	 * @param srcString
	 *            源字符串("true"/"false")
	 * @param defaultValue
	 *            默认值
	 * @return boolean 是否为真
	 */
	public static boolean toBoolean(String srcString, boolean defaultValue) {
		if (srcString == null)
			return false;
		if (srcString.trim().toLowerCase().equals("true"))
			return true;
		else
			return false;
	}

	/**
	 * 按 fromCharset 编码读取，以 toCharset 编码格式输出字符串
	 * 
	 * @param srcString
	 *            源字符串
	 * @param fromCharset
	 *            读取方式编码(UTF-8/GBK/GB2312)
	 * @param toCharset
	 *            输出字符编码(UTF-8/GBK/GB2312)
	 * @return String Charset指定字符串
	 */
	public static String toCharset(String srcString, String fromCharset,
			String toCharset) {
		if (srcString == null) return null;
		try {
			return new String(srcString.getBytes(fromCharset), toCharset);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 把字符串转换为双精度数，默认返回defaultValue
	 * 
	 * @param srcString
	 *            源字符串
	 * @param defaultValue
	 *            默认数值
	 * @return double 双精度数
	 */
	public static double toDouble(String srcString, double defaultValue) {
		double dReturn = 0.0D;
		if (srcString == null || srcString.trim().length() < 1) return defaultValue;
		try {
			srcString = srcString.trim().replaceAll(",", "");
			dReturn = Double.valueOf(srcString.trim()).doubleValue();
		} catch (NumberFormatException e) {
			dReturn = defaultValue;
		}
		return dReturn;
	}

	/**
	 * 把字符串转换为浮点数，默认返回defaultValue
	 * 
	 * @param srcString
	 *            源字符串
	 * @param defaultValue
	 *            默认数值
	 * @return float 浮点数
	 */
	public static float toFloat(String srcString, float defaultValue) {
		float fReturn = 0.0F;
		if (srcString == null || srcString.trim().length() < 1) return defaultValue;
		try {
			srcString = srcString.trim().replaceAll(",", "");
			Double Dv = new Double(Double.valueOf(srcString).doubleValue());
			fReturn = Dv.floatValue();
		} catch (NumberFormatException e) {
			fReturn = defaultValue;
		}
		return fReturn;
	}

	/**
	 * 把字符串转换为整数，默认返回defaultValue
	 * 
	 * @param srcString
	 *            源字符串
	 * @param defaultValue
	 *            默认数值
	 * @return int 取得的数值
	 */
	public static int toInt(String srcString, int defaultValue) {
		int iReturn = 0;
		if (srcString == null || srcString.trim().length() < 1) return defaultValue;
		try {
			srcString = srcString.trim().replaceAll(",", "");
			Double Dv = new Double(Double.valueOf(srcString).doubleValue());
			iReturn = Dv.intValue();
		} catch (NumberFormatException e) {
			iReturn = defaultValue;
		}
		return iReturn;
	}

	/**
	 * 把字符串转换为整数（四舍五入），默认返回defaultValue
	 * 
	 * @param srcString
	 *            源字符串
	 * @param defaultValue
	 *            默认数值
	 * @return int 取得的数值
	 */
	public static int toIntRound(String srcString, int defaultValue) {
		int iReturn = 0;
		if (srcString == null || srcString.trim().length() < 1) return defaultValue;
		try {
			srcString = srcString.trim().replaceAll(",", "");
			float fv = Float.valueOf(srcString).floatValue();
			iReturn = Math.round(fv);
		} catch (NumberFormatException e) {
			iReturn = defaultValue;
		}
		return iReturn;
	}

	/**
	 * 把某种编码字符串转换为Unicode字符串
	 * 
	 * @param srcString
	 *            源字符串
	 * @param fromCharset
	 *            读取方式编码(UTF-8/GBK/GB2312)
	 * @return String 被格式化的Unicode字符串
	 */
	public static String toUnicode(String srcString, String fromCharset) {
		return toCharset(srcString, fromCharset, "ISO-8859-1");
	}

	/**
	 * 以默认编码格式对Unicode字符进行转换
	 * 
	 * @param srcString
	 *            源字符串
	 * @return String 默认字符编码字符串
	 */
	public static String unicodeToString(String srcString) {
		try {
			return new String(srcString.getBytes("ISO-8859-1"));
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 按 Unicode 编码读取，以 toCharset 编码格式输出字符串
	 * 
	 * @param srcString
	 *            源字符串
	 * @param toCharset
	 *            输出字符编码(UTF-8/GBK/GB2312)
	 * @return String Charset指定字符串
	 */
	public static String unicodeToString(String srcString, String toCharset) {
		return toCharset(srcString, "ISO-8859-1", toCharset);
	}

	/**
	 * 字符处理类
	 */
	public StringUtil() {

	}

}