java 数据验证工具类

import java.util.Calendar;
import java.util.Collection;
import java.util.regex.Pattern;

/**
 * @author: wjun.java@gmail.com
 * @date:2015-5-24
 */
public class ValidateUtil {
	/** 字符串缺省状态 */
	private static final boolean DEFAULT_EMPTY_OK = false;

	/** 数字chars */
	private static final String DIGITS = "0123456789";

	/** 小写字母chars */
	public static final String LETTERS_LOWERCASE = "abcdefghijklmnopqrstuvwxyz";

	/** 小写字母chars + 数字 */
	public static final String LETTERS_LOWERCASE_DIGITS = LETTERS_LOWERCASE
			+ DIGITS;

	/** 大写字母chars */
	public static final String LETTERS_UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

	/** 大写字母chars + 数字 */
	public static final String LETTERS_UPPERCASE_DIGITS = LETTERS_UPPERCASE
			+ DIGITS;

	/** 全部字母chars */
	public static final String LETTERS = LETTERS_LOWERCASE + LETTERS_UPPERCASE;

	/** 全部字母数字 */
	public static final String LETTERS_DIGITS = LETTERS + DIGITS;

	/** 空白的chars (包括空格,	,
,
) */
	private static final String WHITE_SPACE = " 	

";

	/** 小数点 */
	private static final String DECIMAL_POING_DELIMITER = ".";

	/** 电话号码里允许的不是数字的chars ,两边括号,横线,空格 */
	private static final String PHONE_NUMBER_DELIMITERS = "()- ";

	/** 全球电话号码允许"+"号的chars */
	private static final String VALID_PHONE_CHARS_WORLD = "+" + DIGITS
			+ PHONE_NUMBER_DELIMITERS;

	/** 手机号码允许"+"号和数字,但只允许第一个字符是+号,验证是检查是否第一个是,如果是去除再验证 */
	private static final String VALID_MSISDN_CHARS = DIGITS;

	/** 手机号码允许的最大长度 */
	private static final int VALID_MSISDN_MAXLEN = 21;

	/** 手机号码允许的最小长度 */
	private static final int VALID_MSISDN_MINLEN = 11;

	/** 定义12月份对应的天数 */
	private static final int[] DAYS_IN_MONTH = { 31, 29, 31, 30, 31, 30, 31,
			31, 30, 31, 30, 31 };

	/** 检查两个对象是否相等 */
	public static boolean isEqual(Object obj, Object obj2) {
		return (obj == null) ? (obj2 == null) : obj.equals(obj2);
	}

	/** 检查字符串是否为空 */
	public static boolean isEmpty(Object obj) {
		if (obj == null)
			return true;

		if (obj instanceof String)
			return isEmpty((String) obj);

		return false;
	}

	/** 检查字符串是否为空 */
	public static boolean isEmpty(String s) {
		return ((s == null) || (s.trim().length() == 0));
	}

	/** 检查集合是否为空 */
	public static boolean isEmpty(Collection<?> c) {
		return ((c == null) || (c.size() == 0));
	}

	/** 检查字符串是否不为空 */
	public static boolean isNotEmpty(String s) {
		return ((s != null) && (s.trim().length() > 0));
	}

	/** 检查集合是否不为空 */
	public static boolean isNotEmpty(Collection<?> c) {
		return ((c != null) && (c.size() > 0));
	}

	/**
	 * 如果s中存在c,则返回true,否则返回false
	 */
	public static boolean isCharInString(char c, String s) {
		return (s.indexOf(c) != -1);
	}

	/** 检查字符是否是大写字母,(注:A-Z之间) */
	public static boolean isLetterUppercase(char c) {
		return LETTERS_UPPERCASE.indexOf(c) != -1;
	}

	/** 检查字符是否是大写字母加数字,(注:A-Z,0-9之间) */
	public static boolean isLetterUppercaseDigits(char c) {
		return LETTERS_UPPERCASE_DIGITS.indexOf(c) != -1;
	}

	/** 检查字符是否是小写字母,(注:a-z之间) */
	public static boolean isLetterLowercase(char c) {
		return LETTERS_LOWERCASE.indexOf(c) != -1;
	}

	/** 检查字符是否是小写字母加数字,(注:a-z,0-9之间) */
	public static boolean isLetterLowercaseDigits(char c) {
		return LETTERS_LOWERCASE_DIGITS.indexOf(c) != -1;
	}

	/** 检查字符是否是字母,(注:a-z,A-Z之间) */
	public static boolean isLetter(char c) {
		return LETTERS.indexOf(c) != -1;
	}

	/** 检查字符是否是数字 */
	public static boolean isDigit(char c) {
		return DIGITS.indexOf(c) != -1;
	}

	/** 检查字符是否是数字或字母 */
	public static boolean isLetterOrDigit(char c) {
		return LETTERS_DIGITS.indexOf(c) != -1;
	}

	/**
	 * 1如果字符串为空或全是whitespace中的值则返回true,存在一个不是则返回false 2见whitespace定义
	 * whitespace = " 	

";(空格,	,
,
)
	 */
	public static boolean isWhitespace(String s) {
		if (isEmpty(s))
			return true;

		// 逐个字符检查,如果发现一个不是whitespace,则返回false
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (WHITE_SPACE.indexOf(c) == -1)
				return false;
		}

		return true;
	}

	/** 检查是否是指定的长度，注:当s=null || s="",min=0时为true */
	public static boolean isLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		return (s.length() >= min && s.length() <= max);
	}

	/** 检查是否GBK编码长度，数据库一般是一个汉字两个字节 */
	public static boolean isByteLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		int len = 0;
		try {
			len = s.getBytes("GBK").length;
		} catch (Exception e) {
			len = s.getBytes().length;
		}
		return (len >= min && len <= max);
	}

	/** 检查是否指定编码长度，UTF-8是一个汉字3个字节，GBK是两个 */
	public static boolean isByteLen(String s, int min, int max, String encoding) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		int len = 0;
		try {
			len = s.getBytes(encoding).length;
		} catch (Exception e) {
			len = s.getBytes().length;
		}
		return (len >= min && len <= max);
	}

	/** 检查是否是整型 */
	public static boolean isInteger(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		// 逐个检查,如果出现一个字符不是数字则返回false
		for (int i = 0; i < s.length(); i++) {
			if (!isDigit(s.charAt(i)))
				return false;
		}

		return true;
	}

	/** 检查是否是带符号的整型(允许第一个字符为"+,-",不接受浮点".",指数"E"等 */
	public static boolean isSignedInteger(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			Integer.parseInt(s);

			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查是否是带符号的长整型(允许第一个字符为"+,-",不接受浮点".",指数"E"等 */
	public static boolean isSignedLong(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			Long.parseLong(s);

			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查是否是一个正整数 */
	public static boolean isPositiveInteger(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			long temp = Long.parseLong(s);

			if (temp > 0)
				return true;
			return false;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查是否是一个非负整数 */
	public static boolean isNonnegativeInteger(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			int temp = Integer.parseInt(s);

			if (temp >= 0)
				return true;
			return false;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查是否是一个负整数 */
	public static boolean isNegativeInteger(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			int temp = Integer.parseInt(s);

			if (temp < 0)
				return true;
			return false;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查是否是一个非正整数 */
	public static boolean isNonpositiveInteger(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			int temp = Integer.parseInt(s);

			if (temp <= 0)
				return true;
			return false;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查字符串是否是整型,且在a,b之间,>=a,<=b */
	public static boolean isIntegerInRange(String s, int a, int b) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		if (!isSignedInteger(s))
			return false;

		int num = Integer.parseInt(s);

		return ((num >= a) && (num <= b));
	}

	/** 检查字符串是否是正整型,且在a,b之间,>=a,<=b */
	public static boolean isIntegerInRangeLen(String s, int a, int b) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		if (!isInteger(s))
			return false;

		return ((s.length() >= a) && (s.length() <= b));
	}

	/** 是否是Unicode码 */
	public static final boolean isUnicode(String str) {
		if (isEmpty(str))
			return false;

		int len = str.length();
		for (int i = 0; i < len; i++) {
			if ((int) str.charAt(i) > 128)
				return true;
		}
		if (str.length() == 1) {
			if (((int) str.charAt(0)) > 128)
				return true;
		}
		return false;

	}

	/** 检查是否是一个无符号的浮点型,不支持指点E */
	public static boolean isFloat(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		if (s.startsWith(DECIMAL_POING_DELIMITER))
			return false;

		// 只允许一个点.
		boolean seenDecimalPoint = false;

		// 逐个字符检查
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);
			if (isDigit(c))
				continue;

			if (c == DECIMAL_POING_DELIMITER.charAt(0)) {
				if (!seenDecimalPoint) {
					seenDecimalPoint = true;
					continue;
				}
			}

			return false;
		}

		return true;
	}

	/** 检查是否是一个允许符号的浮点型,允许符号"+","-" */
	public static boolean isSignedFloat(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			float temp = Float.parseFloat(s);

			if (temp <= 0)
				return true;

			return false;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查是否是一个允许符号的双精度浮点型,允许符号"+","-" */
	public static boolean isSignedDouble(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		try {
			Double.parseDouble(s);
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/** 检查字符串是否都是由字母组成 */
	public static boolean isAlphabetic(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isLetter(c))
				return false;
		}

		return true;
	}

	/** 检查字符串是否都是由小写字母组成 */
	public static boolean isAlphabeticLowercase(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isLetterLowercase(c))
				return false;
		}

		return true;
	}

	/** 检查字符串是否都是由大写字母组成 */
	public static boolean isAlphabeticUppercase(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isLetterUppercase(c))
				return false;
		}

		return true;
	}

	/** 检查字符串是否都是由字母组成且长度在min,max范围内 */
	public static boolean isAlphabeticLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		if (!isAlphabetic(s))
			return false;

		if (s.length() < min || s.length() > max)
			return false;

		return true;
	}

	/** 检查字符串是否都是由小写字母组成且长度在min,max范围内 */
	public static boolean isAlphabeticLowercaseLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		if (!isAlphabeticLowercase(s))
			return false;

		if (s.length() < min || s.length() > max)
			return false;

		return true;
	}

	/** 检查字符串是否都是由大字母组成且长度在min,max范围内 */
	public static boolean isAlphabeticUpperLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		if (!isAlphabeticUppercase(s))
			return false;

		if (s.length() < min || s.length() > max)
			return false;

		return true;
	}

	/** 检查字符串是否都是由字母或数字组成 */
	public static boolean isAlphanumeric(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isLetterOrDigit(c))
				return false;
		}

		return true;
	}

	/** 检查字符串是否都是由字母或数字组成且长度在min,max范围内 */
	public static boolean isAlphanumericLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		if (!isAlphanumeric(s))
			return false;

		if (s.length() < min || s.length() > max)
			return false;

		return true;
	}

	/** 检查字符串是否都是由大写字母或数字组成 */
	public static boolean isAlphaUpperNumeric(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isLetterUppercaseDigits(c))
				return false;
		}

		return true;
	}

	/** 检查字符串是否都是由大写字母或数字组成 */
	public static boolean isAlphaLowerNumeric(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isLetterLowercaseDigits(c))
				return false;
		}

		return true;
	}

	/** 检查字符串是否都是由大写字母或数字组成 */
	public static boolean isAlphaUpperNumericLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		if (!isAlphaUpperNumeric(s))
			return false;

		if (s.length() < min || s.length() > max)
			return false;

		return true;
	}

	/** 检查字符串是否都是由小写字母或数字组成 */
	public static boolean isAlphaLowerNumericLen(String s, int min, int max) {
		if (isEmpty(s))
			return min == 0 ? true : false;

		if (!isAlphaLowerNumeric(s))
			return false;

		if (s.length() < min || s.length() > max)
			return false;

		return true;
	}

	/** 检查字符串是否正确的邮政编码 */
	public static boolean isZipCode(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		if (s.length() != 6 || !isInteger(s))
			return false;

		return true;
	}

	public static boolean isMoneyTwoRadix(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		// 去除负号
		if (s.startsWith("-"))
			s = s.substring(1);

		int ind = s.indexOf(".");
		if (ind == -1)
			return isInteger(s);// 如果没有点号，则判断是否是整数

		if (ind == 0)
			return false;

		String integer = s.substring(0, ind);
		String radix = s.substring(ind + 1);
		if (!isInteger(integer) || !isIntegerInRangeLen(radix, 2, 2))
			return false;// 如果整数部分不是整数，小数部分不是整数，或小数部分不是两位

		return true;
	}

	/** 检查字符串是否正确的邮件地址(注:要求存在@字符,且不是出现在第一个,最后一个位置,现在不检查是否存在".") */
	public static boolean isEmail(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		if (isWhitespace(s))
			return false;

		int indexLeft = s.indexOf('@');
		int indexRight = s.lastIndexOf('@');

		// 如果不存在@,或不止一个,或第一个,或最后一个
		if (indexLeft < 1 || indexLeft != indexRight || indexLeft == s.length())
			return false;

		return true;
	}

	/** 检查是否是正确的年 */
	public static boolean isYear(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		if (!isNonnegativeInteger(s))
			return false;

		return ((s.length() == 2) || (s.length() == 4));
	}

	/** 判断是否是周末 yyyy-MM-dd */
	public static boolean isWeekend(String date) {
		Calendar calendar = DateTimeUtil.toCalendar(date + " 00:00:01");
		return calendar.get(Calendar.DAY_OF_WEEK) == 1;
	}

	/** 判断是否季度末 yyyy-MM-dd */
	public static boolean isMonthQuarter(String date) {
		if (!isDate(date))
			return false;

		String year = date.substring(0, 4);
		String month = date.substring(5, 7);
		String day = date.substring(8);

		if (!isMonthLastDay(year, month, day))
			return false;

		if (month.equals("03") || month.equals("06") || month.equals("09")
				|| month.equals("12"))
			return true;

		return false;
	}

	/** 判断是否年末 yyyy-MM-dd */
	public static boolean isYearLastDay(String date) {
		if (!isDate(date))
			return false;

		String year = date.substring(0, 4);
		String month = date.substring(5, 7);
		String day = date.substring(8);

		if (!isMonthLastDay(year, month, day))
			return false;

		if (month.equals("12"))
			return true;

		return false;
	}

	/** 检查是否是正确的月 */
	public static boolean isMonth(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		return isIntegerInRange(s, 1, 12);
	}

	/** 检查是否是正确的日 */
	public static boolean isDay(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		return isIntegerInRange(s, 1, 31);
	}

	/** 检查是否闰年 */
	public static boolean isLeapYear(int year) {
		return (year % 4 == 0) && ((!(year % 100 == 0)) || (year % 400 == 0));
	}

	/** 检查是否是月末 yyyy-MM-dd HH:mm:ss */
	public static boolean isMonthLastDay(String date) {
		if (!isDate(date))
			return false;

		String year = date.substring(0, 4);
		String month = date.substring(5, 7);
		String day = date.substring(8);
		return isMonthLastDay(year, month, day);
	}

	/** 检查是否是月末 */
	public static boolean isMonthLastDay(String year, String month, String day) {
		if (!isDate(year, month, day))
			return false;

		int yearInt = Integer.parseInt(year);
		int monthInt = Integer.parseInt(month);
		int dayInt = Integer.parseInt(day);
		return isMonthLastDay(yearInt, monthInt, dayInt);
	}

	/** 检查是否是月末 */
	public static boolean isMonthLastDay(int year, int month, int day) {
		if (year < 1000 || year > 9999 || month > 12 || month < 1 || day > 31
				|| day < 1)
			return false;

		switch (month) {
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
			return day == 31;
		case 4:
		case 6:
		case 9:
		case 11:
			return day == 30;
		default:// 2月
			boolean isLeapYear = ValidateUtil.isLeapYear(year);
			return isLeapYear ? day == 29 : day == 28;
		}
	}

	/** 检查是否是正确的时 */
	public static boolean isHour(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		return isIntegerInRange(s, 0, 23);
	}

	/** 检查是否是正确的分 */
	public static boolean isMinute(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;
		return isIntegerInRange(s, 0, 59);
	}

	/** 检查是否是正确的秒 */
	public static boolean isSecond(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;
		return isIntegerInRange(s, 0, 59);
	}

	/** 检查是否是正确的日期 */
	public static boolean isDate(String year, String month, String day) {
		if (!(isYear(year) && isMonth(month) && isDay(day)))
			return false;

		int intYear = Integer.parseInt(year);
		int intMonth = Integer.parseInt(month);
		int intDay = Integer.parseInt(day);

		if (intDay > DAYS_IN_MONTH[intMonth - 1])
			return false;

		if ((intMonth == 2) && (intDay > (isLeapYear(intYear) ? 29 : 28)))
			return false;

		return true;
	}

	/** 检查是否是正确的日期 */
	public static boolean isDate(String date) {
		if (isEmpty(date))
			return DEFAULT_EMPTY_OK;

		if (date.length() != 10)
			return DEFAULT_EMPTY_OK;

		int dateSlash1 = date.indexOf("-");
		int dateSlash2 = date.lastIndexOf("-");

		if (dateSlash1 <= 0 || dateSlash1 == dateSlash2)
			return false;

		String year = date.substring(0, dateSlash1);
		String month = date.substring(dateSlash1 + 1, dateSlash2);
		String day = date.substring(dateSlash2 + 1);

		return isDate(year, month, day);
	}

	/** 判断是不是指定的时间格式 */
	public static boolean isDateTime(String datetime) {
		if (isEmpty(datetime))
			return false;

		datetime = datetime.trim();
		String[] strs = datetime.split(" ");
		if (strs.length != 2)
			return false;

		return isDate(strs[0]) && isTime(strs[1]);
	}

	/** 判断是不是指定的时间格式, spe为日期分隔符 */
	public static boolean isDateTime(String datetime, String spe) {
		if (isEmpty(datetime))
			return false;

		datetime = datetime.trim();
		String[] strs = datetime.split(" ");
		if (strs.length != 2)
			return false;

		return isDate(strs[0].replaceAll(spe, "-")) && isTime(strs[1]);
	}

	/** 检查是否是西方正确的日期 */
	public static boolean isEnglishDate(String date) {
		if (isEmpty(date))
			return DEFAULT_EMPTY_OK;

		int dateSlash1 = date.indexOf("/");
		int dateSlash2 = date.lastIndexOf("/");

		if (dateSlash1 <= 0 || dateSlash1 == dateSlash2)
			return false;

		String month = date.substring(0, dateSlash1);
		String day = date.substring(dateSlash1 + 1, dateSlash2);
		String year = date.substring(dateSlash2 + 1);

		return isDate(year, month, day);
	}

	/** 检查是否是日期比今天大 */
	public static boolean isDateAfterToday(String date) {
		if (isDate(date))
			return DEFAULT_EMPTY_OK;

		java.util.Date passed = DateTimeUtil.toDate(date, "00:00:00");
		java.util.Date now = DateTimeUtil.nowDate();

		return passed.after(now);
	}

	/** 检查是否是正确的时间 */
	public static boolean isTime(String hour, String minute, String second) {
		if (isHour(hour) && isMinute(minute) && isSecond(second))
			return true;

		return false;
	}

	/** 检查是否是正确的时间 */
	public static boolean isTime(String time) {
		if (isEmpty(time))
			return DEFAULT_EMPTY_OK;

		int timeColon1 = time.indexOf(":");
		int timeColon2 = time.lastIndexOf(":");

		if (timeColon1 <= 0 || timeColon1 == timeColon2)
			return false;

		String hour = time.substring(0, timeColon1);
		String minute = time.substring(timeColon1 + 1, timeColon2);
		String second = time.substring(timeColon2 + 1);

		return isTime(hour, minute, second);
	}

	/** 检查是否是正确的电话号码 */
	public static boolean isPhone(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		// 逐个字符检查,如果发现一个不是whitespace,则返回false
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isCharInString(c, VALID_PHONE_CHARS_WORLD))
				return false;
		}

		return true;
	}

	/** 检查是否是正确的手机号码 */
	public static boolean isMsisdn(String s) {
		if (isEmpty(s))
			return DEFAULT_EMPTY_OK;

		// 如果第一个是+号,则去除
		if (s.charAt(0) == '+')
			s = s.substring(1);

		if (s.length() > VALID_MSISDN_MAXLEN
				|| s.length() < VALID_MSISDN_MINLEN)
			return false;

		// 逐个字符检查,如果发现一个不是VALID_MSISDN_CHARS,则返回false
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!isCharInString(c, VALID_MSISDN_CHARS))
				return false;
		}

		return true;
	}

	/**
	 * 判断号码是否符合配置文件所设条件
	 * 
	 * @param phone
	 *            号码字符串
	 * @oaram prefixs 固定前三个的前缀,如135,136,159等,多个用逗号隔开
	 * @return boolean =true 是手机号码,=false 非手机号码
	 */
	public static boolean isMsisdn11(String phone, String prefixs) {
		if (!isIntegerInRangeLen(phone, 11, 11))
			return false;

		String[] prefixArr = prefixs.split(",");
		for (int i = 0; i < prefixArr.length; i++) {
			if (phone.startsWith(prefixArr[i]))
				return true;
		}

		return false;
	}

	/**
	 * 判断号码是否符合配置文件所设条件
	 * 
	 * @param phone
	 *            号码字符串
	 * @param prefixs
	 *            前缀数组，如135,137,+86,0086,17951135等,多个用逗号隔开
	 * @return boolean =true 是手机号码,=false 非手机号码
	 */
	public static boolean isMsisdn21(String phone, String prefixs) {
		if (!isMsisdn(phone))
			return false;

		String[] prefixArr = prefixs.split(",");
		for (int i = 0; i < prefixArr.length; i++) {
			if (phone.length() != prefixArr[i].length() + 8)
				continue;

			if (phone.startsWith(prefixArr[i]))
				return true;
		}

		return false;
	}

	/** 检查是否是IP地址,ip为空返回false; */
	public static boolean isIP(String ip) {
		return isIP(ip, false);
	}

	/** 检查是否是IP地址 */
	public static boolean isIP(String ip, boolean allowEmpty) {
		if (isEmpty(ip))
			return allowEmpty;

		try {
			int ind1 = ip.indexOf('.');
			if (ind1 == -1)
				return false;

			String str1 = ip.substring(0, ind1);
			if (!ValidateUtil.isIntegerInRange(str1, 0, 255))
				return false;

			int ind2 = ip.indexOf('.', ind1 + 1);
			if (ind2 == -1)
				return false;

			String str2 = ip.substring(ind1 + 1, ind2);
			if (!ValidateUtil.isIntegerInRange(str2, 0, 255))
				return false;

			int ind3 = ip.indexOf('.', ind2 + 1);
			if (ind3 == -1)
				return false;

			String str3 = ip.substring(ind2 + 1, ind3);
			if (!ValidateUtil.isIntegerInRange(str3, 0, 255))
				return false;

			String str4 = ip.substring(ind3 + 1);
			if (!ValidateUtil.isIntegerInRange(str4, 0, 255))
				return false;
		} catch (Exception e) {
			return false;
		}
		return true;
	}

	/** 检查是否是macAddress,macAddress为空返回false; */
	public static boolean isMacAddress(String macAddress) {
		return isMacAddress(macAddress, false);
	}

	/** 检查是否是IP地址 */
	public static boolean isMacAddress(String macAddress, boolean allowEmpty) {
		if (isEmpty(macAddress))
			return allowEmpty;

		return isRegExp(
				macAddress,
				"^[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}$");
	}

	/** 检查是否邮编 */
	public static boolean isPostalCode(String s) {
		if (!isInteger(s) || s.trim().length() != 6)
			return false;

		return true;
	}

	/** 检查是否在指定的字符串内 */
	public static boolean isScope(String s, String scope) {
		if (ValidateUtil.isEmpty(s))
			return ValidateUtil.DEFAULT_EMPTY_OK;

		// 逐个字符检查,如果发现一个不是specifyStr,则返回false
		for (int i = 0; i < s.length(); i++) {
			char c = s.charAt(i);

			if (!ValidateUtil.isCharInString(c, scope))
				return false;
		}

		return true;
	}

	/** 检查value是否符合指定的pattern */
	public static boolean isRegExp(String value, String regExp) {
		if (regExp.startsWith("/"))
			regExp = regExp.substring(1);
		if (regExp.endsWith("/"))
			regExp = regExp.substring(0, regExp.length() - 1);
		return Pattern.matches(regExp, value);
	}

	/** 检查src是否包含字符串数组任何一个 */
	public static boolean isStrContainStrArr(String src, String[] strs) {
		for (String str : strs) {
			if (src.contains(str.trim()))
				return true;
		}

		return false;
	}

	/** 检查src是否包含字符串数组任何一个 */
	public static boolean isStrContainStrArr(String src, String strArr,
			String delm) {
		return isStrContainStrArr(src, strArr.split(delm));
	}
}