stringutil.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   StringUtil.java

package org.pf.text;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.StringCharacterIterator;
import java.util.*;

// Referenced classes of package org.pf.text:
//			StringPattern

public class StringUtil
{

	public static final char CH_SPACE = 32;
	public static final char CH_NEWLINE = 10;
	public static final char CH_CR = 13;
	public static final char CH_TAB = 9;
	public static final String STR_SPACE = " ";
	public static final String STR_NEWLINE = "\n";
	public static final String STR_CR = "\r";
	public static final String STR_TAB = "\t";
	private static final String WORD_DELIM = " \t\n\r";
	private static StringUtil singleton = null;

	public StringUtil()
	{
	}

	private static StringUtil getSingleton()
	{
		return singleton;
	}

	private static void setSingleton(StringUtil inst)
	{
		singleton = inst;
	}

	public static StringUtil current()
	{
		if (getSingleton() == null)
			setSingleton(new StringUtil());
		return getSingleton();
	}

	public String replaceAll(String sourceStr, String oldSubStr, String newSubStr)
	{
		String part = null;
		String result = "";
		int index = -1;
		int subLen = 0;
		subLen = oldSubStr.length();
		for (part = sourceStr; part.length() > 0 && subLen > 0;)
		{
			index = part.indexOf(oldSubStr);
			if (index >= 0)
			{
				result = (new StringBuilder()).append(result).append(part.substring(0, index)).append(newSubStr).toString();
				part = part.substring(index + subLen);
			} else
			{
				result = (new StringBuilder()).append(result).append(part).toString();
				part = "";
			}
		}

		return result;
	}

	public String repeat(char ch, int count)
	{
		StringBuffer buffer = null;
		buffer = new StringBuffer(count);
		for (int i = 1; i <= count; i++)
			buffer.append(ch);

		return buffer.toString();
	}

	public String[] words(String text)
	{
		return parts(text, " \t\n\r");
	}

	public String[] parts(String text, String delimiters)
	{
		return parts(text, delimiters, false);
	}

	public String[] allParts(String text, String delimiters)
	{
		return parts(text, delimiters, true);
	}

	public String[] substrings(String text, String separator)
	{
		return substrings(text, separator, false);
	}

	public String[] allSubstrings(String text, String separator)
	{
		return substrings(text, separator, true);
	}

	public String getDelimitedSubstring(String text, String startDelimiter, String endDelimiter)
	{
		String subStr = "";
		if (text != null && startDelimiter != null && endDelimiter != null)
		{
			int start = text.indexOf(startDelimiter);
			if (start >= 0)
			{
				int stop = text.indexOf(endDelimiter, start + 1);
				if (stop > start)
					subStr = text.substring(start + 1, stop);
			}
		}
		return subStr;
	}

	public String getDelimitedSubstring(String text, String delimiter)
	{
		return getDelimitedSubstring(text, delimiter, delimiter);
	}

	public String stackTrace(Throwable throwable)
	{
		StringWriter sw = new StringWriter();
		PrintWriter pw = new PrintWriter(sw);
		throwable.printStackTrace(pw);
		pw.close();
		return sw.toString();
	}

	public String leftPadCh(String str, int len, char ch)
	{
		return padCh(str, len, ch, true);
	}

	public String leftPad(String str, int len)
	{
		return leftPadCh(str, len, ' ');
	}

	public String leftPadCh(int value, int len, char fillChar)
	{
		return leftPadCh(Integer.toString(value), len, fillChar);
	}

	public String leftPad(int value, int len)
	{
		return leftPadCh(value, len, '0');
	}

	public String rightPadCh(String str, int len, char ch)
	{
		return padCh(str, len, ch, false);
	}

	public String rightPad(String str, int len)
	{
		return rightPadCh(str, len, ' ');
	}

	public String rightPadCh(int value, int len, char fillChar)
	{
		return rightPadCh(Integer.toString(value), len, fillChar);
	}

	public String rightPad(int value, int len)
	{
		return rightPadCh(value, len, ' ');
	}

	public String centerCh(String str, int len, char ch)
	{
		String buffer = null;
		int missing = len - str.length();
		int half = 0;
		if (missing <= 0)
		{
			return str;
		} else
		{
			half = missing / 2;
			buffer = rightPadCh(str, len - half, ch);
			return leftPadCh(buffer, len, ch);
		}
	}

	public String center(String str, int len)
	{
		return centerCh(str, len, ' ');
	}

	public String[] append(String strings[], String string)
	{
		String appStr[] = {
			string
		};
		return append(strings, appStr);
	}

	public String[] append(String strings[], String appendStrings[])
	{
		String newStrings[] = null;
		if (strings == null)
			return appendStrings;
		if (appendStrings == null)
		{
			return strings;
		} else
		{
			newStrings = new String[strings.length + appendStrings.length];
			System.arraycopy(strings, 0, newStrings, 0, strings.length);
			System.arraycopy(appendStrings, 0, newStrings, strings.length, appendStrings.length);
			return newStrings;
		}
	}

	public String[] appendIfNotThere(String strings[], String appendString)
	{
		if (contains(strings, appendString))
			return strings;
		else
			return append(strings, appendString);
	}

	public String[] appendIfNotThere(String strings[], String appendStrings[])
	{
		String newStrings[] = strings;
		if (appendStrings == null)
			return newStrings;
		for (int i = 0; i < appendStrings.length; i++)
			newStrings = appendIfNotThere(newStrings, appendStrings[i]);

		return newStrings;
	}

	public String[] remove(String strings[], String removeStrings[])
	{
		if (strings == null || removeStrings == null || strings.length == 0 || removeStrings.length == 0)
			return strings;
		else
			return removeFromStringArray(strings, removeStrings);
	}

	public String[] remove(String strings[], String removeString)
	{
		String removeStrings[] = {
			removeString
		};
		return remove(strings, removeStrings);
	}

	public String[] removeNull(String strings[])
	{
		if (strings == null)
			return strings;
		else
			return removeFromStringArray(strings, null);
	}

	public String asString(String strings[], String separator)
	{
		StringBuffer buffer = null;
		buffer = new StringBuffer(strings.length * 20);
		if (strings.length > 0)
		{
			buffer.append(strings[0].toString());
			for (int i = 1; i < strings.length; i++)
			{
				buffer.append(separator);
				if (strings[i] != null)
					buffer.append(strings[i]);
			}

		}
		return buffer.toString();
	}

	public String asString(String strings[])
	{
		return asString(strings, ",");
	}

	public int indexOf(String strArray[], StringPattern pattern)
	{
		if (strArray == null || strArray.length == 0)
			return -1;
		boolean found = false;
		for (int i = 0; i < strArray.length; i++)
		{
			if (strArray[i] == null)
			{
				if (pattern == null)
					found = true;
			} else
			if (pattern != null)
				found = pattern.matches(strArray[i]);
			if (found)
				return i;
		}

		return -1;
	}

	public int indexOf(String strArray[], String searchStr)
	{
		return indexOfString(strArray, searchStr, false);
	}

	public int indexOfIgnoreCase(String strArray[], String searchStr)
	{
		return indexOfString(strArray, searchStr, true);
	}

	public boolean contains(String strArray[], String searchStr, boolean ignoreCase)
	{
		if (ignoreCase)
			return containsIgnoreCase(strArray, searchStr);
		else
			return contains(strArray, searchStr);
	}

	public boolean contains(String strArray[], StringPattern pattern)
	{
		return indexOf(strArray, pattern) >= 0;
	}

	public boolean contains(String strArray[], String searchStr)
	{
		return indexOf(strArray, searchStr) >= 0;
	}

	public boolean containsIgnoreCase(String strArray[], String searchStr)
	{
		return indexOfIgnoreCase(strArray, searchStr) >= 0;
	}

	public String[] copyFrom(String from[], int start)