commons-lang NumberUtilHelper

除了对字符串的复杂处理，对于数字，我们也是头大啊，类型，位移等等操作，如果写在程序里，无疑是天文数字，而工具类可以统一计算和管理

package org.ycl.commons.text;

import org.apache.commons.lang.StringUtils;

/**
 * 1. leftBit
 * <li>- 2^N, assign: this seat digit is one Auth</li>
 * 2. validAuth
 * <li>- X&N, assign: X' N seat digit has Auth</li>
 * 3. addAuth
 * <li>- X|N, assign: set X' N seat digit to 1</li>
 * 4. removeAuth
 * <li>- X^N, assign: set X' N seat digit to 0</li>
 * 5. toInt/toLong/toFloat/toDouble/toByte/toShort
 * <li>- null-letter safe Number convert</li>
 * 6. min/max
 * <li>- find array's min/max</li>
 * 7. isDigits/isNumber
 * <li>- judge string is digits/number</li>
 * 
 * NOTE:this is from my tool box
 * {@link org.apache.commons.lang.math.NumberUtils} 
 * 
 * @author e557400
 *
 */
public class NumberUtils {
 
	/**
	 * <<: move to left, fill 0 in right part
	 * this will be return 2^N
	 * 
	 * index
	 * 1         2
	 * 2         4
	 * 3         8
	 * ....
	 * 
	 * process
	 * 
	 * NUM: 1    BIT: 2^0==> 1
	 * OP:  <<   left
	 * NUM: 3
	 * EQ:  1000 ==> BIT: 2^3 ==> 8
	 * 
	 * NOTE: int is 32 bits
	 * exp int i=1, so i's 2 bits' source code:
	 * 00000000000000000000000000000001
	 * 
	 * @param index
	 * @return 2^index
	 */
	private static int leftBit(int index){
		return 1<<index;
	}
	
	/**
	 * &: only two is 1, then 1, others is 0.
	 * check whether the value's index bit is 1.
	 * 
	 * NUM: 6, 1
	 * leftBig: 1<<1 ==> 10
	 *          6 ==> 2^2+2^1 ==>110
	 * OP: 10&110==>10
	 * 
	 * @param value
	 * @param index
	 * @return
	 */
	public static boolean validAuth(int value, int index){
		return (leftBit(index)&value)==leftBit(index);
	}
	
	/**
	 * |: only two is 0, then 0, others is 1
	 * add value's index.
	 * 
	 * NUM: 6, 3
	 * leftBig: 1<<3 ==> 1000
	 *          6 ==> 2^2+2^1 ==>110
	 * OP: 1000|110==>1110 ==>2^3+6 = 14
	 * 
	 * @param value
	 * @param index
	 * @return
	 */
	public static int addAuth(int value, int index){
		return leftBit(index)|value;
	}
	
	/**
	 * ^: only two is same, then 0, others is 1
	 * 
     *NUM: 14, 3
	 * leftBig: 1<<3 ==> 1000
	 *          6 ==> 2^3+2^2+2^1 ==>1110
	 * OP: 1000^1110==>0110 ==>6
	 * 
	 * @param value
	 * @param index
	 * @return
	 */
	public static int removeAuth(int value, int index){
		if(validAuth(value,index)){
			return leftBit(index)^value;
		}else{
			return value;
		}
		
	}
	
	/**
     * <p>Convert a <code>String</code> to an <code>int</code>, returning
     * <code>zero</code> if the conversion fails.</p>
     *
     * <p>If the string is <code>null</code>, <code>zero</code> is returned.</p>
     *
     * <pre>
     *   NumberUtils.toInt(null) = 0
     *   NumberUtils.toInt("")   = 0
     *   NumberUtils.toInt("1")  = 1
     * </pre>
     *
     * @param str  the string to convert, may be null
     * @return the int represented by the string, or <code>zero</code> if
     *  conversion fails
     * @since 2.1
     */
    public static int toInt(String str) {
    	return org.apache.commons.lang.math.NumberUtils.toInt(str);
    }
    
    /**
     * <p>Returns the minimum value in an array.</p>
     * 
     * @param array  an array, must not be null or empty
     * @return the minimum value in the array
     * @throws IllegalArgumentException if <code>array</code> is <code>null</code>
     * @throws IllegalArgumentException if <code>array</code> is empty
     */
    public static long min(long[] array) {
        // Validates input
        if (array == null) {
            throw new IllegalArgumentException("The Array must not be null");
        } else if (array.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty.");
        }
    
        // Finds and returns min
        long min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
        }
    
        return min;
    }
    
    /**
     * <p>Checks whether the <code>String</code> contains only
     * digit characters.</p>
     *
     * <p><code>Null</code> and empty String will return
     * <code>false</code>.</p>
     *
     * @param str  the <code>String</code> to check
     * @return <code>true</code> if str contains only unicode numeric
     */
    public static boolean isDigits(String str) {
        if (StringUtils.isEmpty(str)) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }
    
    /**
     * <p>Checks whether the String a valid Java number.</p>
     *
     * <p>Valid numbers include hexadecimal marked with the <code>0x</code>
     * qualifier, scientific notation and numbers marked with a type
     * qualifier (e.g. 123L).</p>
     *
     * <p><code>Null</code> and empty String will return
     * <code>false</code>.</p>
     *
     * @param str  the <code>String</code> to check
     * @return <code>true</code> if the string is a correctly formatted number
     */
    public static boolean isNumber(String str) {
        if (StringUtils.isEmpty(str)) {
            return false;
        }
        char[] chars = str.toCharArray();
        int sz = chars.length;
        boolean hasExp = false;
        boolean hasDecPoint = false;
        boolean allowSigns = false;
        boolean foundDigit = false;
        // deal with any possible sign up front
        int start = (chars[0] == '-') ? 1 : 0;
        if (sz > start + 1) {
            if (chars[start] == '0' && chars[start + 1] == 'x') {
                int i = start + 2;
                if (i == sz) {
                    return false; // str == "0x"
                }
                // checking hex (it can't be anything else)
                for (; i < chars.length; i++) {
                    if ((chars[i] < '0' || chars[i] > '9')
                        && (chars[i] < 'a' || chars[i] > 'f')
                        && (chars[i] < 'A' || chars[i] > 'F')) {
                        return false;
                    }
                }
                return true;
            }
        }
        sz--; // don't want to loop to the last char, check it afterwords
              // for type qualifiers
        int i = start;
        // loop to the next to last char or to the last char if we need another digit to
        // make a valid number (e.g. chars[0..5] = "1234E")
        while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) {
            if (chars[i] >= '0' && chars[i] <= '9') {
                foundDigit = true;
                allowSigns = false;

            } else if (chars[i] == '.') {
                if (hasDecPoint || hasExp) {
                    // two decimal points or dec in exponent   
                    return false;
                }
                hasDecPoint = true;
            } else if (chars[i] == 'e' || chars[i] == 'E') {
                // we've already taken care of hex.
                if (hasExp) {
                    // two E's
                    return false;
                }
                if (!foundDigit) {
                    return false;
                }
                hasExp = true;
                allowSigns = true;
            } else if (chars[i] == '+' || chars[i] == '-') {
                if (!allowSigns) {
                    return false;
                }
                allowSigns = false;
                foundDigit = false; // we need a digit after the E
            } else {
                return false;
            }
            i++;
        }
        if (i < chars.length) {
            if (chars[i] >= '0' && chars[i] <= '9') {
                // no type qualifier, OK
                return true;
            }
            if (chars[i] == 'e' || chars[i] == 'E') {
                // can't have an E at the last byte
                return false;
            }
            if (chars[i] == '.') {
                if (hasDecPoint || hasExp) {
                    // two decimal points or dec in exponent
                    return false;
                }
                // single trailing decimal point after non-exponent is ok
                return foundDigit;
            }
            if (!allowSigns
                && (chars[i] == 'd'
                    || chars[i] == 'D'
                    || chars[i] == 'f'
                    || chars[i] == 'F')) {
                return foundDigit;
            }
            if (chars[i] == 'l'
                || chars[i] == 'L') {
                // not allowing L with an exponent
                return foundDigit && !hasExp;
            }
            // last character is illegal
            return false;
        }
        // allowSigns is true iff the val ends in 'E'
        // found digit it to make sure weird stuff like '.' and '1E-' doesn't pass
        return !allowSigns && foundDigit;
    }
	
	
	 public static void main(String args[]){
		 System.out.println(leftBit(1));
		 System.out.println(leftBit(2));
		 System.out.println(leftBit(3));
		 System.out.println(leftBit(4));
		 
		 System.out.println(addAuth(6,3)); 
		 
		 System.out.println(validAuth(6,1));
		 System.out.println(validAuth(6,2));
		 System.out.println(validAuth(14,3));
		 
		 System.out.println(removeAuth(6,3));
		 
		 System.out.println(org.apache.commons.lang.math.NumberUtils.isNumber(""));
		 System.out.println(org.apache.commons.lang.math.NumberUtils.isNumber(" "));
		 System.out.println(org.apache.commons.lang.math.NumberUtils.isNumber(null));
	 }
}