stringutil.java

一个专门用来快速开发网站的框架

package com.common.ubb;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;


/**
 * 功能：<br>
 * 1,将字符串加密 encodePassword(String passWord,String algorithm),<br>
 * encodeString(String str)<br>
 * 2,将字符串解密 decodeString(String str)，该方法只针对采用了BASE64加密的字符串<br>
 * 3,抓取网页元素 parserHtmlContent(String resource, String path, String filename, int
 * num)<br>
 * 4,分解字符串 parse(String chain, char splitChar)<br>
 * 5,拼装字符串 assdate(List datelist, char SPLITTER)<br>
 * 6,取最大公约数 gcd(int firstNum, int secondNum)<br>
 * 7,页面元素转换 picture(String face, String start, String end)<br>
 */
public class StringUtil {

	private final static Log log = LogFactory.getLog(StringUtil.class);

	/**
	 * 将一个字符串加密 param password表示要加密的字符串，algorithm表示加密的类型
	 * 
	 * @param password
	 *            原始密码
	 * @param algorithm
	 *            加密类型
	 * @return String
	 */
	public static String encodePassword(String passWord, String algorithm) {
		byte[] unencodedPassword = passWord.getBytes();

		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance(algorithm);
		} catch (Exception e) {
			log.error("Exception: " + e);
			return passWord;
		}
		md.reset();
		md.update(unencodedPassword);

		// 计算hash值
		byte[] encodedPassword = md.digest();
		StringBuffer buf = new StringBuffer();
		for (int i = 0; i < encodedPassword.length; i++) {
			if ((encodedPassword[i] & 0xff) < 0x10) {
				buf.append("0");
			}
			buf.append(Long.toString(encodedPassword[i] & 0xff, 16));
		}
		return buf.toString().substring(8, 24);
	}

	/**
	 * 将一个字符串用64为加密，这种加密不是很安全，很容易被解密出来
	 * 
	 * @param str表示要加密的字符串
	 * @return String 加密后的字符串
	 */
	public static String encodeString(String str) {
		sun.misc.BASE64Encoder encoder = new sun.misc.BASE64Encoder();
		return encoder.encodeBuffer(str.getBytes()).trim();
	}

	/**
	 * 抓取网页技术
	 * 
	 * @param resource
	 *            要抓取的资源路径(URL)
	 * @param path
	 *            生成的文件路径
	 * @param filename
	 *            生成的文件名
	 * @param num
	 *            要抓取的Table位置
	 * @return
	 * @throws Exception
	 */
//	public String parserHtmlContent(String resource, String path,
//			String filename, int num) throws Exception {
//		Parser myParser = new Parser(resource);
//
//		// 设置编码
//		myParser.setEncoding("gbk");
//		String filterStr = "table";
//		NodeFilter filter = new TagNameFilter(filterStr);
//		NodeList nodeList = myParser.extractAllNodesThatMatch(filter);
//		TableTag tabletag = (TableTag) nodeList.elementAt(num);
//		String separator = System.getProperty("file.separator");
//		FileWriter fw = new FileWriter(path + separator + separator + filename);
//
//		if (num == 30) {
//			fw.write("<table width=778 align=center border=0 cellspacing=0 cellpadding=0><tr><td>");
//		}
//		String regPattern = "href=[\\\"\\'](http:\\/\\/|\\.\\/|\\/)?\\w+(\\.\\w+)*(\\/\\w+(\\.\\w+)?)*(\\/|\\?\\w*=\\w*(&\\w*=\\w*)*)?[\\\"\\']";
//		fw.write(Pattern.compile(regPattern).matcher(tabletag.toHtml())
//				.replaceAll("href=\"#\""));
//		if (num == 30) {
//			fw.write("</td></tr></table>");
//		}
//		PrintWriter out = new PrintWriter(new BufferedWriter(fw));
//
//		fw.close();
//		out.close();
//
//		return tabletag.toHtml();
//	}

	/**
	 * 把一个通过64位加密(BASE64)的字符串解密出来
	 * 
	 * @param str
	 *            要解密的字符串
	 * @return String 解密后的字符串
	 */
	public static String decodeString(String str) {
		sun.misc.BASE64Decoder dec = new sun.misc.BASE64Decoder();
		try {
			return new String(dec.decodeBuffer(str));
		} catch (IOException io) {
			throw new RuntimeException(io.getMessage(), io.getCause());
		}
	}

	/**
	 * 将把用符号分隔的字符串转化成一个list
	 * 
	 * @param chain
	 *            用符号分隔的字符串
	 * @param splitChar
	 *            分隔符
	 * @return list
	 * 
	 */
	public static List parse(String chain, char splitChar) {
		String[] strs = org.apache.commons.lang.StringUtils.split(chain,
				splitChar);
		List datalist = new ArrayList();
		for (int i = 0; i < strs.length; i++) {
			datalist.add(strs[i]);
		}
		return datalist;
	}

	/**
	 * 将一个list转化成字符串，字符串将以SPLITTER作为分隔符
	 * 
	 * @param dataList
	 *            要转化的list
	 * @param SPLITTER
	 *            分隔符
	 * @return 拼装后的字符串
	 */
	public static String assdate(List dataList, char SPLITTER) {
		StringBuffer strbuf = new StringBuffer();
		for (int i = 0; i < dataList.size() ; i++) {
			strbuf.append(dataList.get(i)).append(SPLITTER);
		}
		
		return strbuf.toString();
	}
	public static String assdate(Object[] dataList, char SPLITTER) {
		StringBuffer strbuf = new StringBuffer();
		for (int i = 0; i < dataList.length ; i++) {
			strbuf.append(dataList[i]).append(SPLITTER);
		}
		
		return strbuf.toString();
	}
	/**
	 * 计算两个数的最大公约数
	 * 
	 * @param firstNum
	 *            第一个数
	 * @param secondNum
	 *            第二个数
	 * @return int 两个数的最大公约数
	 */
	public static int gcd(int firstNum, int secondNum) {
		if (0 == firstNum) {
			return secondNum;
		}
		if (0 == secondNum) {
			return firstNum;
		}
		if (firstNum > secondNum) {
			swap(firstNum, secondNum);
		}
		int c;
		for (c = firstNum % secondNum; c > 0; c = firstNum % secondNum) {
			firstNum = secondNum;
			secondNum = c;
		}
		return secondNum;
	}

	/**
	 * 交换两个整型变量的值
	 * 
	 * @param firstNum
	 *            前一个数
	 * @param secondNum
	 *            后一个数
	 */
	public static void swap(int firstNum, int secondNum) {
		int c = firstNum;
		firstNum = secondNum;
		secondNum = c;
	}

	/**
	 * 将一个格式为[face]*.gif|jpg|...[/face]的字符串，转化为"<img src="*.gif|jpg|..."
	 * width="20",height="20">"的字符串，用于页面输出如发帖心情之类的元素.
	 * 
	 * @param face
	 *            表情标签
	 * @param start
	 *            分割的起始元素
	 * @param end
	 *            分割的结束元素
	 * @return String 形如"<img src="*.gif|jpg|... width="20" height="20">"的字符串
	 */
	public static String picture(String face, String start, String end) {
		String j = face;
		String s = StringUtils.substringBetween(face, start, end);
		if (s != null) {

			String img = "";
			if (start.equals("[face]"))
				img = "<img src='" + s + "' width='20' heigth='20'>";

			j = StringUtils.replace(face, start + s + end, img);

			return picture(j, start, end);
		} else {
			return j;
		}
	}
	
	/**
	 * 返回一指定了高度和宽度的格式为:<br>
	 * "<img src=""*.gif|jpg|..." "width=""..." "height=""..."">"的字符串，用于页面输出如头像,发贴心情之类的元素<br>
	 * 类似的参考picture(String face,String start,String end)
	 * @param face 表情标签
	 * @param start 分割的起始元素
	 * @param end 分割的结束元素
	 * @param width 生成的图片的宽度
	 * @param height 生成的图片的高度
	 * @return String
	 */
	public static String picture(String face, String start, String end,String width,String height){
		String j=face;
		String s=StringUtils.substringBetween(face,start,end);
		if(s!=null){
			StringBuffer img=new StringBuffer();
			if(start.equals("[face]")){
				img.append("<img src='");
				img.append(s);
				img.append("' width='");
				img.append(width);
				img.append("' height='");
				img.append(height);
				img.append("'>");
			}
			j=StringUtils.replace(face,start+s+end,img.toString());
			/**如果还有类似的元素,则继续转换,直到全部转换完成*/
			return picture(j,start,end,width,height);
		}else{
			return j;
		}
	}
	/**
	 * 替换字符串
	 * 
	 * @param source
	 *            要被替换整个字符串
	 * @param oldChar
	 *            要被替换的子串
	 * @param newChar
	 *            替换的子串
	 * @return String 返回被替换后的整个字符串
	 */
	public static String replaceString(String source, String oldString,
			String newString) {
		if (source == null || oldString == null || newString == null)
			return "";
		else
			return replace(source, oldString, newString);
	}
	private static String replace(String source, String oldString,
			String newString) {
		StringBuffer output = new StringBuffer();
		int lengthOfSource = source.length();
		int lengthOfOld = oldString.length();
		int posStart;
		int pos;
		for (posStart = 0; (pos = source.indexOf(oldString, posStart)) >= 0; posStart = pos
				+ lengthOfOld) {
			output.append(source.substring(posStart, pos));
			output.append(newString);
		}

		if (posStart < lengthOfSource)
			output.append(source.substring(posStart));
		return output.toString();
	}

}