util.java

分页类,包括中文和英文及其他语言种类,便于二次开发及商业开发,

package com.laoer.comm.util;

import java.util.regex.*;
import sun.misc.*;
import java.io.*;
import java.security.*;
import java.text.*;
import java.net.*;
import java.util.*;

/**
 * <p>Title: 天乙软件工作室公共包</p>
 * <p>Description: 天乙软件工作室公共包</p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: 天乙软件工作室[LAOER.COM/TIANYISOFT.NET]</p>
 * @author 龚天乙(Laoer)
 * @version 1.0
 */

public class Util {

  private static final char[] QUOTE_ENCODE = "&quot;".toCharArray();
  private static final char[] AMP_ENCODE = "&amp;".toCharArray();
  private static final char[] LT_ENCODE = "&lt;".toCharArray();
  private static final char[] GT_ENCODE = "&gt;".toCharArray();
  private static MessageDigest digest = null;

  public Util() {
  }

  public static boolean validateUserName(String username) {
    Pattern p = Pattern.compile("^\\w+$");
    Matcher m = p.matcher(username);
    if (m.find()) {
      return true;
    }
    return false;
  }

  public static String Array2String(String[] values) {
    String result = "";
    if (values == null) {
      return result;
    }
    int len = values.length;
    for (int i = 0; i < len; i++) {
      result += values[i] + ",";
    }
    if (result.endsWith(",")) {
      result = result.substring(result.length() - 1);
    }
    return result;
  }

  public static String Array2String(Object[] values) {
    String result = "";
    if (values == null) {
      return result;
    }
    int len = values.length;
    for (int i = 0; i < len; i++) {
      result += values[i].toString() + ",";
    }
    if (result.endsWith(",")) {
      result = result.substring(result.length() - 1);
    }
    return result;
  }

  public static String Array2String(List values) {
    String result = "";
    if (values == null) {
      return result;
    }
    int len = values.size();
    for (int i = 0; i < len; i++) {
      result += values.get(i).toString() + ",";
    }
    if (result.endsWith(",")) {
      result = result.substring(result.length() - 1);
    }
    return result;
  }

  public static String base64Encode(String txt) {
    if (txt != null && txt.length() > 0) {
      txt = new sun.misc.BASE64Encoder().encode(txt.getBytes());
    }
    return txt;
  }

  public static String base64Encode(byte[] txt) {
    String encodeTxt = "";
    if (txt != null && txt.length > 0) {
      encodeTxt = new sun.misc.BASE64Encoder().encode(txt);
    }
    return encodeTxt;
  }

  public static String base64decode(String txt) {
    if (txt != null && txt.length() > 0) {
      byte[] buf;
      try {
        buf = new sun.misc.BASE64Decoder().decodeBuffer(txt);
        txt = new String(buf);
      }
      catch (IOException ex) {
      }
    }
    return txt;
  }

  public static byte[] base64decodebyte(String txt) {
    byte[] buf = null;
    if (txt != null && txt.length() > 0) {
      try {
        buf = new sun.misc.BASE64Decoder().decodeBuffer(txt);
      }
      catch (IOException ex) {
      }
    }
    return buf;
  }

  /**
   * Replaces all instances of oldString with newString in line.
   *
   * @param line the String to search to perform replacements on
   * @param oldString the String that should be replaced by newString
   * @param newString the String that will replace all instances of oldString
   *
   * @return a String will all instances of oldString replaced by newString
   */
  public static final String replace(String line, String oldString,
                                     String newString) {
    if (line == null) {
      return null;
    }
    int i = 0;
    if ( (i = line.indexOf(oldString, i)) >= 0) {
      char[] line2 = line.toCharArray();
      char[] newString2 = newString.toCharArray();
      int oLength = oldString.length();
      StringBuffer buf = new StringBuffer(line2.length);
      buf.append(line2, 0, i).append(newString2);
      i += oLength;
      int j = i;
      while ( (i = line.indexOf(oldString, i)) > 0) {
        buf.append(line2, j, i - j).append(newString2);
        i += oLength;
        j = i;
      }
      buf.append(line2, j, line2.length - j);
      return buf.toString();
    }
    return line;
  }

  /**
   * Replaces all instances of oldString with newString in line with the
   * added feature that matches of newString in oldString ignore case.
   *
   * @param line the String to search to perform replacements on
   * @param oldString the String that should be replaced by newString
   * @param newString the String that will replace all instances of oldString
   *
   * @return a String will all instances of oldString replaced by newString
   */
  public static final String replaceIgnoreCase(String line, String oldString,
                                               String newString) {
    if (line == null) {
      return null;
    }
    String lcLine = line.toLowerCase();
    String lcOldString = oldString.toLowerCase();
    int i = 0;
    if ( (i = lcLine.indexOf(lcOldString, i)) >= 0) {
      char[] line2 = line.toCharArray();
      char[] newString2 = newString.toCharArray();
      int oLength = oldString.length();
      StringBuffer buf = new StringBuffer(line2.length);
      buf.append(line2, 0, i).append(newString2);
      i += oLength;
      int j = i;
      while ( (i = lcLine.indexOf(lcOldString, i)) > 0) {
        buf.append(line2, j, i - j).append(newString2);
        i += oLength;
        j = i;
      }
      buf.append(line2, j, line2.length - j);
      return buf.toString();
    }
    return line;
  }

  /**
   * Replaces all instances of oldString with newString in line with the
   * added feature that matches of newString in oldString ignore case.
   * The count paramater is set to the number of replaces performed.
   *
   * @param line the String to search to perform replacements on
   * @param oldString the String that should be replaced by newString
   * @param newString the String that will replace all instances of oldString
   * @param count a value that will be updated with the number of replaces
   *      performed.
   *
   * @return a String will all instances of oldString replaced by newString
   */
  public static final String replaceIgnoreCase(String line, String oldString,
                                               String newString, int[] count) {
    if (line == null) {
      return null;
    }
    String lcLine = line.toLowerCase();
    String lcOldString = oldString.toLowerCase();
    int i = 0;
    if ( (i = lcLine.indexOf(lcOldString, i)) >= 0) {
      int counter = 0;
      char[] line2 = line.toCharArray();
      char[] newString2 = newString.toCharArray();
      int oLength = oldString.length();
      StringBuffer buf = new StringBuffer(line2.length);
      buf.append(line2, 0, i).append(newString2);
      i += oLength;
      int j = i;
      while ( (i = lcLine.indexOf(lcOldString, i)) > 0) {
        counter++;
        buf.append(line2, j, i - j).append(newString2);
        i += oLength;
        j = i;
      }
      buf.append(line2, j, line2.length - j);
      count[0] = counter;
      return buf.toString();
    }
    return line;
  }

  /**
   * Replaces all instances of oldString with newString in line.
   * The count Integer is updated with number of replaces.
   *
   * @param line the String to search to perform replacements on
   * @param oldString the String that should be replaced by newString
   * @param newString the String that will replace all instances of oldString
   *
   * @return a String will all instances of oldString replaced by newString
   */
  public static final String replace(String line, String oldString,
                                     String newString, int[] count) {
    if (line == null) {
      return null;
    }
    int i = 0;
    if ( (i = line.indexOf(oldString, i)) >= 0) {
      int counter = 0;
      counter++;
      char[] line2 = line.toCharArray();
      char[] newString2 = newString.toCharArray();
      int oLength = oldString.length();
      StringBuffer buf = new StringBuffer(line2.length);
      buf.append(line2, 0, i).append(newString2);
      i += oLength;
      int j = i;
      while ( (i = line.indexOf(oldString, i)) > 0) {
        counter++;
        buf.append(line2, j, i - j).append(newString2);
        i += oLength;
        j = i;
      }
      buf.append(line2, j, line2.length - j);
      count[0] = counter;
      return buf.toString();
    }
    return line;
  }

  /**
   * This method takes a string which may contain HTML tags (ie, &lt;b&gt;,
   * &lt;table&gt;, etc) and converts the '&lt'' and '&gt;' characters to
   * their HTML escape sequences.
   *
   * @param in the text to be converted.
   * @return the input string with the characters '&lt;' and '&gt;' replaced
   *  with their HTML escape sequences.
   */
  public static final String escapeHTMLTags(String in) {
    if (in == null) {
      return null;
    }
    char ch;
    int i = 0;
    int last = 0;
    char[] input = in.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(GT_ENCODE);
      }
    }
    if (last == 0) {
      return in;
    }
    if (i > last) {
      out.append(input, last, i - last);
    }
    return out.toString();
  }

  /**
   * Hashes a String using the Md5 algorithm and returns the result as a
   * String of hexadecimal numbers. This method is synchronized to avoid
   * excessive MessageDigest object creation. If calling this method becomes
   * a bottleneck in your code, you may wish to maintain a pool of
   * MessageDigest objects instead of using this method.
   * <p>
   * A hash is a one-way function -- that is, given an
   * input, an output is easily computed. However, given the output, the
   * input is almost impossible to compute. This is useful for passwords
   * since we can store the hash and a hacker will then have a very hard time
   * determining the original password.
   * <p>
   * In Jive, every time a user logs in, we simply
   * take their plain text password, compute the hash, and compare the
   * generated hash to the stored hash. Since it is almost impossible that
   * two passwords will generate the same hash, we know if the user gave us
   * the correct password or not. The only negative to this system is that
   * password recovery is basically impossible. Therefore, a reset password
   * method is used instead.
   *
   * @param data the String to compute the hash of.
   * @return a hashed version of the passed-in String
   */
  public synchronized static final String hash(String data) {
    if (digest == null) {
      try {
        digest = MessageDigest.getInstance("MD5");
      }
      catch (NoSuchAlgorithmException nsae) {
        System.err.println("Failed to load the MD5 MessageDigest. " +
                           "We will be unable to function normally.");
        nsae.printStackTrace();
      }
    }
    // Now, compute hash.
    digest.update(data.getBytes());
    return encodeHex(digest.digest());
  }

  /**
   * Turns an array of bytes into a String representing each byte as an
   * unsigned hex number.
   * <p>
   * Method by Santeri Paavolainen, Helsinki Finland 1996<br>
   * (c) Santeri Paavolainen, Helsinki Finland 1996<br>
   * Distributed under LGPL.
   *
   * @param bytes an array of bytes to convert to a hex-string
   * @return generated hex string
   */
  public static final String encodeHex(byte[] bytes) {
    StringBuffer buf = new StringBuffer(bytes.length * 2);
    int i;