Java类型判空

package com.dsyh.util;

	import java.math.BigDecimal;
	import java.math.BigInteger;
	import java.util.Arrays;
	
	/**
	 * 数值助手
	 *
	 * @author luohao
	 *
	 */
	public class NumberHelper {
	
	    private NumberHelper() {
	        throw new SecurityException();
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Byte a,
	            Byte b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Character a,
	            Character b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Short a,
	            Short b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Integer a,
	            Integer b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Long a,
	            Long b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Float a,
	            Float b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            Double a,
	            Double b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            BigInteger a,
	            BigInteger b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否相等
	     *
	     * @param a
	     *            数值a
	     * @param b
	     *            数值b
	     * @return 是否相等
	     */
	    public static boolean isEquals(
	            BigDecimal a,
	            BigDecimal b) {
	        return a != null && b != null && a.compareTo(b) == 0;
	    }
	
	    /**
	     * 判断是否小于等于0
	     *
	     * @param number
	     *            数值
	     * @return 是否小于等于0
	     */
	    public static boolean ltZero(
	            Number number) {
	        return !greaterZero(number);
	    }
	
	    /**
	     * 判断是否大于0
	     *
	     * @param number
	     *            数值
	     * @return 是否大于0
	     */
	    public static boolean gtZero(
	            Number number) {
	        return greaterZero(number);
	    }
	
	    /**
	     * 判断是否大于0
	     *
	     * @param number
	     *            数值
	     * @return 是否大于0
	     */
	    public static boolean greaterZero(
	            Number number) {
	        return number != null && number.doubleValue() > 0;
	    }
	
	    /**
	     * 判断是否大于0
	     *
	     * @param numbers
	     *            数值列表
	     * @return 是否大于0
	     */
	    public static boolean anyGreaterZero(
	            Number... numbers) {
	        if (numbers == null || numbers.length == 0) {
	            return false;
	        }
	        return Arrays.stream(numbers).anyMatch(NumberHelper::greaterZero);
	    }
	
	    /**
	     * 判断是否大于0
	     *
	     * @param numbers
	     *            数值列表
	     * @return 是否大于0
	     */
	    public static boolean allGreaterZero(
	            Number... numbers) {
	        if (numbers == null || numbers.length == 0) {
	            return false;
	        }
	        return Arrays.stream(numbers).allMatch(NumberHelper::greaterZero);
	    }
	
	    /**
	     * 判断是否大于等于0
	     *
	     * @param number
	     *            数值
	     * @return 是否大于等于0
	     */
	    public static boolean greaterOrEqualZero(
	            Number number) {
	        return number != null && number.doubleValue() >= 0;
	    }
	
	    /**
	     * 判断是否大于等于0
	     *
	     * @param numbers
	     *            数值列表
	     * @return 是否大于等于0
	     */
	    public static boolean anyGreaterOrEqualZero(
	            Number... numbers) {
	        if (numbers == null || numbers.length == 0) {
	            return false;
	        }
	        return Arrays.stream(numbers).anyMatch(NumberHelper::greaterOrEqualZero);
	    }
	
	    /**
	     * 判断是否大于等于0
	     *
	     * @param numbers
	     *            数值列表
	     * @return 是否大于等于0
	     */
	    public static boolean allGreaterOrEqualZero(
	            Number... numbers) {
	        if (numbers == null || numbers.length == 0) {
	            return false;
	        }
	        return Arrays.stream(numbers).allMatch(NumberHelper::greaterOrEqualZero);
	    }
	
	}