package com.winsun.utils;

import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Map;

/**
 * 判断非空工具类
 * 
 *
 * 
 * @version v1.4 2016-12-19
 * @since 2016-2-12
 */
public class Is {

	/**
	 * 私有化构造对象,不能创建对象
	 */
	private Is() {
		super();
		throw new UnsupportedOperationException("cannot be instantiated");
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            整形
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(byte num) {
		return num > 0 ? true : false;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(byte[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (byte i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            整形
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(short num) {
		return num > 0 ? true : false;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(short[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (short i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            整数
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(int num) {
		return num > 0 ? true : false;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(int[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (int i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            浮点数
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(float num) {
		return num > 0 ? true : false;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(float[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (float i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            双精度浮点数
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(double num) {
		return num > 0 ? true : false;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(double[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (double i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            长整数
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(long num) {
		return num > 0 ? true : false;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(long[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (long i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否大于0
	 * 
	 * @param num
	 *            数字
	 * @return true为大于0,false为小于0
	 */
	public static boolean isNoEmpty(Number num) {
		boolean flag = false;
		if (null != num) {
			if (num.doubleValue() > 0) {
				flag = true;
			}
		}
		return flag;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param nums
	 *            数组
	 * @return 如果array不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(Number[] nums) {
		boolean flag = false;
		if (nums != null && nums.length > 0) {
			for (Number i : nums) {
				if (Is.isNoEmpty(i)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param str
	 *            字符串
	 * @return 如果str不为空返回true
	 */
	public static boolean isNoEmpty(String str) {
		boolean flag = false;
		if (str != null && str.replaceAll("//s*", "").length() > 0) {
			flag = true;
		}
		return flag;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param strs
	 *            字符串数组
	 * @return 如果strs不为空(存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(String[] strs) {
		boolean flag = false;
		if (strs != null && strs.length > 0) {
			for (String s : strs) {
				if (Is.isNoEmpty(s)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param list
	 *            list集合或set集合
	 * @return 如果list不为空(list存在至少有一个值不为空)返回true
	 */
	public static <T> boolean isNoEmpty(Collection<T> list) {
		boolean flag = false;
		if (list != null && list.size() > 0) {
			for (T l : list) {
				if (Is.isNoEmpty(l)) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param map
	 *            map集合
	 * @return 如果map不为空(map存在至少有一个值不为空)返回true
	 */
	public static boolean isNoEmpty(Map<?, ?> map) {
		boolean flag = false;
		if (map != null && map.size() > 0) {
			for (Map.Entry<?, ?> entry : map.entrySet()) {
				if (Is.isNoEmpty(entry.getValue())) {
					flag = true;
					break;
				}
			}
		}
		return flag;
	}

	/**
	 * 判断是否为空
	 * 
	 * @param objs
	 *            数据集
	 * @return 如果都不为空且有值且不为负数返回true
	 */
	public static boolean isNoEmpty(Object... objs) {
		boolean flag = true;
		if(objs!=null){
			for (Object obj : objs) {
				// 任意一项都不能为空
				if (obj == null) {
					flag = false;
					break;
				}
				// 判断不同数据是否符合规则
				if (obj instanceof Number) {
					// 数字
					if (((Number) obj).doubleValue() <= 0) {
						flag = false;
						break;
					}
				} else if (obj instanceof String) {
					// 字符
					if (((String) obj).replaceAll("//s*", "").length() <= 0) {
						flag = false;
						break;
					}
				} else if (obj instanceof Collection) {
					// 集合
					if (!Is.isNoEmpty((Collection<?>) obj)) {
						flag = false;
						break;
					}
				} else if (obj instanceof Map) {
					// 集合
					if (!Is.isNoEmpty((Map<?, ?>) obj)) {
						flag = false;
						break;
					}
				} else if (obj.getClass().isArray()) {
					// 数组
					if (Array.getLength(obj) <= 0) {
						flag = false;
						break;
					}
				}
			}
		}else{
			flag = false;
		}
		return flag;
	}

	/**
	 * 为空或为零时返回默认值
	 * 
	 * @param t
	 *            参数
	 * @param def
	 *            默认值
	 * @return t为空时返回def
	 */
	public static <T> T ifNull(T t, T def) {
		if (!Is.isNoEmpty(t)) {
			// 为空
			t = def;
		}
		return t;
	}

	/**
	 * 去除所有空格,换行符,换页符
	 * 
	 * @param str
	 *            字符串
	 * @return 去除后的字符串
	 */
	public static String trim(String str) {
		return str != null ? str.replaceAll("\\s*|\t|\r|\n", "") : str;
	}
	
	public static Object ifValue(Object obj){
		if(obj=="" || null==obj || obj==" "){
			return null;
		}
		return obj;
	}
	public static boolean isEmpty(Object str){
		if (Is.isNoEmpty(str)) {
			return false;
		}
		return true;
	}
	
	/**
	 * obj转str
	 * @param obj
	 * @return
	 */
	public static String parseStr(Object obj){
		return Is.ifNull(obj, "").toString();
	}
}
