public static String format(String message,
    Object[] params) 
{
		int currentParamNumber = 0;
		StringBuffer formattedMessage = new StringBuffer();
		for (int i = 0; i <  message.length(); i++) {
			if (message.charAt(i) == '%") {
				if (currentParamNumber  >= params.length) {
					formattedMessage.append("?missing data?");
				} else if (
					(params[currentParamNumber] instanceof Number)
						&& (i + 1 <  message.length())) {
					i
						+= matchOptionalFormatting(
							(Number) params[currentParamNumber++],
							message.substring(i + 1),
							formattedMessage);
				} else {
					formattedMessage.append(
						params[currentParamNumber++].toString());
				}
			} else {
				if ((message.charAt(i) == '\\")
					&& (i + 1 <  message.length())
					&& (message.charAt(i + 1) == '%")) {
					formattedMessage.append('%");
					i++;
				} else {
					formattedMessage.append(message.charAt(i));
				}
			}
		}
		return formattedMessage.toString();
}

Apply printf() like formatting to a string. Primarily used for logging.

 public static String getFromCompressedUnicode(byte[] string,
    int offset,
    int len) 
{
		try {
			int len_to_use = Math.min(len, string.length - offset);
			return new String(string, offset, len_to_use, "ISO-8859-1");
		} catch (UnsupportedEncodingException e) {
			throw new InternalError(); /* unreachable */
		}
}

Read 8 bit data (in ISO-8859-1 codepage) into a (unicode) Java String and return. (In Excel terms, read compressed 8 bit unicode as a string)

 public static String getFromUnicodeBE(byte[] string) 
{
		if(string.length == 0) { return ""; }
		return getFromUnicodeBE(string, 0, string.length / 2);
}

Given a byte array of 16-bit unicode characters in big endian format (most important byte first), return a Java String representation of it. { 0x00, 0x16 } -0x16

 public static String getFromUnicodeBE(byte[] string,
    int offset,
    int len) throws IllegalArgumentException, ArrayIndexOutOfBoundsException 
{
		if ((offset <  0) || (offset  >= string.length)) {
			throw new ArrayIndexOutOfBoundsException("Illegal offset");
		}
		if ((len <  0) || (((string.length - offset) / 2) <  len)) {
			throw new IllegalArgumentException("Illegal length");
		}
		try {
			return new String(string, offset, len * 2, "UTF-16BE");
		} catch (UnsupportedEncodingException e) {
			throw new InternalError(); /*unreachable*/
		}
}

Given a byte array of 16-bit unicode characters in big endian format (most important byte first), return a Java String representation of it. { 0x00, 0x16 } -0x16

 public static String getFromUnicodeLE(byte[] string) 
{
		if(string.length == 0) { return ""; }
		return getFromUnicodeLE(string, 0, string.length / 2);
}

Given a byte array of 16-bit unicode characters in little endian format (most important byte last), return a Java String representation of it. { 0x16, 0x00 } -0x16

 public static String getFromUnicodeLE(byte[] string,
    int offset,
    int len) throws IllegalArgumentException, ArrayIndexOutOfBoundsException 
{
		if ((offset <  0) || (offset  >= string.length)) {
			throw new ArrayIndexOutOfBoundsException("Illegal offset");
		}
		if ((len <  0) || (((string.length - offset) / 2) <  len)) {
			throw new IllegalArgumentException("Illegal length");
		}
		try {
			return new String(string, offset, len * 2, "UTF-16LE");
		} catch (UnsupportedEncodingException e) {
			throw new InternalError(); /*unreachable*/
		}
}

Given a byte array of 16-bit unicode characters in Little Endian format (most important byte last), return a Java String representation of it. { 0x16, 0x00 } -0x16

 public static String getPreferredEncoding() 
{
		return ENCODING;
}

 public static boolean hasMultibyte(String value) 
{
	    if( value == null )return false;
	    for(int i = 0 ; i <  value.length() ; i++ ){
	        char c = value.charAt(i);
	        if(c  > 0xFF )return true;
	    }
	    return false;
}

check the parameter has multibyte character

 public static boolean isUnicodeString(String value) 
{
	    try {
	      return !value.equals(new String(value.getBytes("ISO-8859-1"), "ISO-8859-1"));
	    } catch (UnsupportedEncodingException e) {
	      return true;
	    }
}

Checks to see if a given String needs to be represented as Unicode

 public static  void putCompressedUnicode(String input,
    byte[] output,
    int offset) 
{
		try {
			byte[] bytes = input.getBytes("ISO-8859-1");
			System.arraycopy(bytes, 0, output, offset, bytes.length);
		} catch (UnsupportedEncodingException e) {
			throw new InternalError(); /*unreachable*/
		}
}

Takes a unicode (java) string, and returns it as 8 bit data (in ISO-8859-1 codepage). (In Excel terms, write compressed 8 bit unicode)

 public static  void putUnicodeBE(String input,
    byte[] output,
    int offset) 
{
		try {
			byte[] bytes = input.getBytes("UTF-16BE");
			System.arraycopy(bytes, 0, output, offset, bytes.length);
		} catch (UnsupportedEncodingException e) {
			throw new InternalError(); /*unreachable*/
		}
}

Takes a unicode string, and returns it as big endian (most important byte first) bytes in the supplied byte array. (In Excel terms, write uncompressed unicode)

 public static  void putUnicodeLE(String input,
    byte[] output,
    int offset) 
{
		try {
			byte[] bytes = input.getBytes("UTF-16LE");
			System.arraycopy(bytes, 0, output, offset, bytes.length);
		} catch (UnsupportedEncodingException e) {
			throw new InternalError(); /*unreachable*/
		}
}

Takes a unicode string, and returns it as little endian (most important byte last) bytes in the supplied byte array. (In Excel terms, write uncompressed unicode)