stringutils.java

products program INSTRACTION item

			if (i < len) {
				c = data[i] & 0x3f;
				ret.append(cvt.charAt(c));
			} else {
				ret.append((char) fillchar);
			}
		}
		return ret.toString();
	}

	/**
	 * Decodes a base64 String.
	 *
	 * @param data a base64 encoded String to decode.
	 * @return the decoded String.
	 */
	public static String decodeBase64(String data) {
		return decodeBase64(data.getBytes());
	}

	/**
	 * Decodes a base64 aray of bytes.
	 *
	 * @param data a base64 encode byte array to decode.
	 * @return the decoded String.
	 */
	public static String decodeBase64(byte[] data) {
		int c, c1;
		int len = data.length;
		StringBuffer ret = new StringBuffer((len * 3) / 4);
		for (int i = 0; i < len; ++i) {
			c = cvt.indexOf(data[i]);
			++i;
			c1 = cvt.indexOf(data[i]);
			c = ((c << 2) | ((c1 >> 4) & 0x3));
			ret.append((char) c);
			if (++i < len) {
				c = data[i];
				if (fillchar == c)
					break;

				c = cvt.indexOf((char) c);
				c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf);
				ret.append((char) c1);
			}

			if (++i < len) {
				c1 = data[i];
				if (fillchar == c1)
					break;

				c1 = cvt.indexOf((char) c1);
				c = ((c << 6) & 0xc0) | c1;
				ret.append((char) c);
			}
		}
		return ret.toString();
	}

	private static final int fillchar = '=';
	private static final String cvt =
		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
			+ "abcdefghijklmnopqrstuvwxyz"
			+ "0123456789+/";

	/**
	 * Converts a line of text into an array of lower case words using a
	 * BreakIterator.wordInstance(). <p>
	 *
	 * This method is under the Jive Open Source Software License and was
	 * written by Mark Imbriaco.
	 *
	 * @param text a String of text to convert into an array of words
	 * @return text broken up into an array of words.
	 */
	public static final String[] toLowerCaseWordArray(String text) {
		if (text == null || text.length() == 0) {
			return new String[0];
		}

		ArrayList wordList = new ArrayList();
		BreakIterator boundary = BreakIterator.getWordInstance();
		boundary.setText(text);
		int start = 0;

		for (int end = boundary.next();
			end != BreakIterator.DONE;
			start = end, end = boundary.next()) {
			String tmp = text.substring(start, end).trim();
			// Remove characters that are not needed.
			tmp = replace(tmp, "+", "");
			tmp = replace(tmp, "/", "");
			tmp = replace(tmp, "\\", "");
			tmp = replace(tmp, "#", "");
			tmp = replace(tmp, "*", "");
			tmp = replace(tmp, ")", "");
			tmp = replace(tmp, "(", "");
			tmp = replace(tmp, "&", "");
			if (tmp.length() > 0) {
				wordList.add(tmp);
			}
		}
		return (String[]) wordList.toArray(new String[wordList.size()]);
	}

	/**
	 * Pseudo-random number generator object for use with randomString().
	 * The Random class is not considered to be cryptographically secure, so
	 * only use these random Strings for low to medium security applications.
	 */
	private static Random randGen = new Random();

	/**
	 * Array of numbers and letters of mixed case. Numbers appear in the list
	 * twice so that there is a more equal chance that a number will be picked.
	 * We can use the array to get a random number or letter by picking a random
	 * array index.
	 */
	private static char[] numbersAndLetters =
		("0123456789abcdefghijklmnopqrstuvwxyz"
			+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
			.toCharArray();

	/**
	 * Returns a random String of numbers and letters (lower and upper case)
	 * of the specified length. The method uses the Random class that is
	 * built-in to Java which is suitable for low to medium grade security uses.
	 * This means that the output is only pseudo random, i.e., each number is
	 * mathematically generated so is not truly random.<p>
	 *
	 * The specified length must be at least one. If not, the method will return
	 * null.
	 *
	 * @param length the desired length of the random String to return.
	 * @return a random String of numbers and letters of the specified length.
	 */
	public static final String randomString(int length) {
		if (length < 1) {
			return null;
		}
		// Create a char buffer to put random letters and numbers in.
		char[] randBuffer = new char[length];
		for (int i = 0; i < randBuffer.length; i++) {
			randBuffer[i] = numbersAndLetters[randGen.nextInt(71)];
		}
		return new String(randBuffer);
	}

	/**
	 * Intelligently chops a String at a word boundary (whitespace) that occurs
	 * at the specified index in the argument or before. However, if there is a
	 * newline character before <code>length</code>, the String will be chopped
	 * there. If no newline or whitespace is found in <code>string</code> up to
	 * the index <code>length</code>, the String will chopped at <code>length</code>.
	 * <p>
	 * For example, chopAtWord("This is a nice String", 10) will return
	 * "This is a" which is the first word boundary less than or equal to 10
	 * characters into the original String.
	 *
	 * @param string the String to chop.
	 * @param length the index in <code>string</code> to start looking for a
	 *       whitespace boundary at.
	 * @return a substring of <code>string</code> whose length is less than or
	 *       equal to <code>length</code>, and that is chopped at whitespace.
	 */
	public static final String chopAtWord(String string, int length) {
		if (string == null) {
			return string;
		}

		char[] charArray = string.toCharArray();
		int sLength = string.length();
		if (length < sLength) {
			sLength = length;
		}

		// First check if there is a newline character before length; if so,
		// chop word there.
		for (int i = 0; i < sLength - 1; i++) {
			// Windows
			if (charArray[i] == '\r' && charArray[i + 1] == '\n') {
				return string.substring(0, i + 1);
			}
			// Unix
			else if (charArray[i] == '\n') {
				return string.substring(0, i);
			}
		}
		// Also check boundary case of Unix newline
		if (charArray[sLength - 1] == '\n') {
			return string.substring(0, sLength - 1);
		}

		// Done checking for newline, now see if the total string is less than
		// the specified chop point.
		if (string.length() < length) {
			return string;
		}

		// No newline, so chop at the first whitespace.
		for (int i = length - 1; i > 0; i--) {
			if (charArray[i] == ' ') {
				return string.substring(0, i).trim();
			}
		}

		// Did not find word boundary so return original String chopped at
		// specified length.
		return string.substring(0, length);
	}

	/**
	 * Escapes all necessary characters in the String so that it can be used
	 * in an XML doc.
	 *
	 * @param string the string to escape.
	 * @return the string with appropriate characters escaped.
	 */
	public static final String escapeForXML(String string) {
		if (string == null) {
			return null;
		}
		char ch;
		int i = 0;
		int last = 0;
		char[] input = string.toCharArray();
		int len = input.length;
		StringBuffer out = new StringBuffer((int) (len * 1.3));
		for (; i < len; i++) {
			ch = input[i];
			if (ch > '>') {
				continue;
			} else if (ch == '<') {
				if (i > last) {
					out.append(input, last, i - last);
				}
				last = i + 1;
				out.append(LT_ENCODE);
			} else if (ch == '&') {
				if (i > last) {
					out.append(input, last, i - last);
				}
				last = i + 1;
				out.append(AMP_ENCODE);
			} else if (ch == '"') {
				if (i > last) {
					out.append(input, last, i - last);
				}
				last = i + 1;
				out.append(QUOTE_ENCODE);
			}
		}
		if (last == 0) {
			return string;
		}
		if (i > last) {
			out.append(input, last, i - last);
		}
		return out.toString();
	}

	/**
	 * Unescapes the String by converting XML escape sequences back into normal
	 * characters.
	 *
	 * @param string the string to unescape.
	 * @return the string with appropriate characters unescaped.
	 */
	public static final String unescapeFromXML(String string) {
		string = replace(string, "&lt;", "<");
		string = replace(string, "&gt;", ">");
		string = replace(string, "&quot;", "\"");
		return replace(string, "&amp;", "&");
	}

	public static java.lang.String[] split(
		java.lang.String text,
		java.lang.String separator) {
		return org.apache.commons.lang.StringUtils.split(text, separator);
	}

	private static final char[] zeroArray = "0000000000000000".toCharArray();

	/**
	 * Pads the supplied String with 0's to the specified length and returns
	 * the result as a new String. For example, if the initial String is
	 * "9999" and the desired length is 8, the result would be "00009999".
	 * This type of padding is useful for creating numerical values that need
	 * to be stored and sorted as character data. Note: the current
	 * implementation of this method allows for a maximum <tt>length</tt> of
	 * 16.
	 *
	 * @param string the original String to pad.
	 * @param length the desired length of the new padded String.
	 * @return a new String padded with the required number of 0's.
	 */
	public static final String zeroPadString(String string, int length) {
		if (string == null || string.length() > length) {
			return string;
		}
		StringBuffer buf = new StringBuffer(length);
		buf.append(zeroArray, 0, length - string.length()).append(string);
		return buf.toString();
	}

	/**
	 * Formats a Date as a fifteen character long String made up of the Date's
	 * padded millisecond value.
	 *
	 * @return a Date encoded as a String.
	 */
	public static final String dateToMillis(Date date) {
		return zeroPadString(Long.toString(date.getTime()), 15);
	}

	public static final String isnTo8859(String aString) {
		ISN isn = new ISN();
		String result = isn.isnORA(aString);
		return result;
	}

	/**
	 * Method HTMLEncode.
	 * 还原字符串里面的特殊字符,包括回车,空格等信息
	 * @param src
	 * @return String
	 */
	// 
	public static String HTMLEncode(String src) {
		StringBuffer newString = new StringBuffer();
		if (src == null)
			return "&nbsp";
		char next;
		for (int i = 0; i < src.length(); i++) {
			next = src.charAt(i);
			if (next == '>') {
				newString.append("&gt;");
			} else if (next == '<') {
				newString.append("&lt;");
			} else if (next == ' ') {
				newString.append("&nbsp;");
			} else if (next == '&') {
				newString.append("&amp;");
			} else if (next == '"') {
				newString.append("&quot;");
			} else if (next == 39) { // The "'"
				newString.append("&rsquo;");
			} else if (next == 13) {
				newString.append("<br/>");
				//			}else if (next == 10){
				//				newString.append("<br/>");
			} else {
				newString.append(next);
			}
		}
		return newString.toString();
	}

	/**
	 * Method replaceString.
	 * 替换字符串中的一部分
	 * @param parentStr
	 * @param ch
	 * @param rep
	 * @return String
	 */
	public String replaceString(String parentStr, String ch, String rep) {
		int i = parentStr.indexOf(ch);
		StringBuffer sb = new StringBuffer();
		if (i == -1)
			return parentStr;
		sb.append(parentStr.substring(0, i) + rep);
		if (i + ch.length() < parentStr.length())
			sb.append(
				replace(
					parentStr.substring(i + ch.length(), parentStr.length()),
					ch,
					rep));
		return sb.toString();
	}
	public static final String getStorage(String aStorage) {
		String temp = "";
		if ("永久".equals(aStorage)) {
			temp = "Y";
		} else if ("长期".equals(aStorage)) {
			temp = "C";
		} else {
			temp = "D";
		}
		return temp;
	}
   

    public static final String toString(long aNumber,int aBit){
    String result=Long.toString(aNumber);
    long length=result.length() ;
    for (int i=0;i<aBit-length;i++){
    result="0"+result;
    }
    return result;
    }

//add by zhuwb 2004-3-9
    public  static final boolean isGWH(String name){
    	boolean bl=(name.indexOf("办")!=-1)||(name.indexOf("住")!=-1)||(name.indexOf("张泽森")!=-1)||(name.indexOf("王迅")!=-1)||(name.indexOf("吴怀荣")!=-1)||(name.indexOf("李庆博")!=-1||(name.indexOf("办备用")!=-1));
    	if(bl){
    		return false;
    	}else{
    		return true;
    	}
    }
    
}