Java-文字列がIPアドレスかどうかを判断

  /**
   *              IP   
   *
   * @param str    
   */
  public static boolean isIpStr(String str) {
    //   
    // boolean notBlank = StringUtils.isNotBlank(str);
    //       0.0.0.0 - 255.255.255.255
    // boolean length = CommonUtils.isNumberBetween(str.length(),7,15);

    if (StringUtils.isNotBlank(str) && CommonUtils.isNumberBetween(str.length(), 7, 15)) {
      String regex = ".";
      //             
      if (str.contains(regex) && str.split(regex).length == 4) {
        boolean legalNumber = true;
        //        ，         
        for (String obj : Lists.newArrayList(str.split(regex))) {
          if (NumberUtils.isDigit(obj)) {
            Integer value = Integer.parseInt(obj);
            legalNumber = CommonUtils.isNumberBetween(value, 0, 255);
          } else {
            //         ，   
            legalNumber = false;
            break;
          }
        }
        return legalNumber;
      }
    }
    return false;
  }

package cn.zjcs.common.util;

import cn.hutool.core.util.ReUtil;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * @author Created by    on 2019/6/11.    . 15:20.
 * © All Rights Reserved.
 */

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class CommonUtils {


  /**
   *     null
   *
   * @param o
   * @return null   true
   */
  public static boolean isNull(Object o) {
    return o == null;
  }

  /**
   *      null
   *
   * @param o
   * @return    null    true
   */
  public static boolean isNotNull(Object o) {
    return !isNull(o);
  }

  /**
   *    0 ，
   *
   * @param bigDecimal
   * @return 0   true
   */
  public static boolean isZeroDecimal(BigDecimal bigDecimal) {
    return isNotNull(bigDecimal) && bigDecimal.compareTo(BigDecimal.ZERO) == 0;
  }

  /**
   *      0
   *
   * @param bigDecimal
   * @return   0   true
   */
  public static boolean isNotZeroDecimal(BigDecimal bigDecimal) {
    return !isZeroDecimal(bigDecimal);
  }

  /**
   *     1
   *
   * @param bigDecimal
   * @return   1   true
   */
  public static boolean isOneDecimal(BigDecimal bigDecimal) {
    return isNotNull(bigDecimal) && bigDecimal.compareTo(BigDecimal.ONE) == 0;
  }

  /**
   *      1
   *
   * @param bigDecimal
   * @return    1   true
   */
  public static boolean isNotOneDecimal(BigDecimal bigDecimal) {
    return bigDecimal.compareTo(BigDecimal.ONE) != 0;
  }

  /**
   *     0 long
   *
   * @param l
   * @return   0 long    true
   */
  public static boolean isZeroLong(Long l) {
    return l != null && l.equals(0L);
  }

  /**
   *      0 long
   *
   * @param l
   * @return    0 long    true
   */
  public static boolean isNotZeroLong(Long l) {
    return !isZeroLong(l);
  }

  /**
   *     0 int
   *
   * @param l
   * @return   0 int    true
   */
  public static boolean isZeroInt(Integer l) {
    return l != null && l.equals(0);
  }

  /**
   *      0 int
   *
   * @param l
   * @return    0 int    true
   */
  public static boolean isNotZeroInt(Integer l) {
    return !isZeroInt(l);
  }

  /**
   *    decimal     
   *
   * @param i
   * @param j
   * @return      true
   */
  public static boolean isSameDecimal(BigDecimal i, BigDecimal j) {
    return i.compareTo(j) == 0;
  }

  /**
   *     decimal          decimal
   *
   * @param i
   * @param j
   * @return      true
   */
  public static boolean isDecimalGt(BigDecimal i, BigDecimal j) {
    return i.compareTo(j) > 0;
  }

  /**
   *     decimal          decimal
   *
   * @param i
   * @param j
   * @return      true
   */
  public static boolean isDecimalLt(BigDecimal i, BigDecimal j) {
    return i.compareTo(j) < 0;
  }

  /**
   *        
   *
   * @param character
   * @return
   */
  public static String replaceSpecialCharacter(String character) {
    String regEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
    return ReUtil.replaceAll(character, regEx, "");
  }

  /**
   *       
   * 

   *    p   2，      ，  h    "1000.00"
   *      0.002
   *
   * @param p    
   * @param h    
   * @return      
   */
  public static BigDecimal percentFormat(Integer p, String h) {
    return new BigDecimal(String.valueOf(p)).divide(new BigDecimal(h), 4, RoundingMode.HALF_UP).setScale(4, BigDecimal.ROUND_HALF_UP);
  }

  public static boolean orEq(Object... o) {
    if (o.length < 2) {
      throw new NullPointerException("    ");
    }
    Object o1 = o[0];
    for (int i = 1; i < o.length - 1; i++) {
      if (o1.equals(o[i])) {
        return true;
      }
    }
    return false;
  }

  /**
   *      
   *
   * @param number    
   * @param min      
   * @param max      
   */
  public static boolean isNumberBetween(Number number, Number min, Number max) {
    return number.longValue() >= min.longValue() && number.longValue() <= max.longValue();
  }


  /**
   *       
   */
  @NoArgsConstructor(access = AccessLevel.PRIVATE)
  public static class Math {

    /**
     *             ，    double       
     */
    @SuppressWarnings("rawtypes")
    @Getter
    public static class Fraction extends Number implements Comparable {
      private static final long serialVersionUID = 2330398718018182597L;
      /**
       *     
       */
      private long numerator = 0;
      /**
       *     
       */
      private long denominator = 1;

      public Fraction() {
        this(0, 1);
      }

      public Fraction(long numerator, long denominator) {
        long gcd = gcd(numerator, denominator);
        this.numerator = ((denominator > 0) ? 1 : -1) * numerator / gcd;
        this.denominator = java.lang.Math.abs(denominator) / gcd;
      }

      /**
       *       
       */
      private long gcd(long f, long s) {
        long fAbs = java.lang.Math.abs(f);
        long sAbs = java.lang.Math.abs(s);
        //      Gcd
        int _Gcd = 1;
        //       
        for (int i = 1; i <= fAbs && i <= sAbs; i++) {
          if (fAbs % i == 0 && sAbs % i == 0) {
            _Gcd = i;
          }
        }
        return _Gcd;
      }

      /**
       *      
       *
       */
      public Fraction add(Fraction secondRational) {
        long n = numerator * secondRational.getDenominator() + denominator * secondRational.getNumerator();
        long d = denominator * secondRational.getDenominator();
        return new Fraction(n, d);
      }

      /**
       *      
       *
       */
      public Fraction subtract(Fraction secondRational) {
        long n = numerator * secondRational.getDenominator() - denominator * secondRational.getNumerator();
        long d = denominator * secondRational.getDenominator();
        return new Fraction(n, d);
      }

      /**
       *     
       *
       */
      public Fraction mulitiply(Fraction secondRational) {
        long n = numerator * secondRational.getNumerator();
        long d = denominator * secondRational.getDenominator();
        return new Fraction(n, d);
      }

      /**
       *     
       *
       */
      public Fraction divide(Fraction secondRational) {
        long n = numerator * secondRational.getDenominator();
        long d = denominator * secondRational.numerator;
        return new Fraction(n, d);
      }

      @Override
      public String toString() {
        if (denominator == 1) {
          return numerator + "";
        } else {
          return numerator + "/" + denominator;
        }

      }

      @SuppressWarnings("all")
      @Override
      public boolean equals(Object parm1) {
        return (this.subtract((Fraction) (parm1))).getNumerator() == 0;
      }

      @Override
      public int compareTo(Object o) {
        if ((this.subtract((Fraction) o)).getNumerator() > 0) {
          return 1;
        } else if ((this.subtract((Fraction) o)).getNumerator() > 0) {
          return -1;
        } else {
          return 0;
        }

      }

      @Override
      public double doubleValue() {
        return numerator * 1.0 / denominator;
      }

      @Override
      public float floatValue() {
        return (float) doubleValue();
      }

      @Override
      public int intValue() {
        return (int) doubleValue();
      }

      @Override
      public long longValue() {
        return (long) doubleValue();
      }
    }


    /**
     * @param dividend    
     * @param divisor    
     * @param accuracy   
     */
    public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor, int accuracy) {
      // 0       =    ，      0    ，      
      if (isZeroDecimal(divisor) || isZeroDecimal(dividend)) {
        return BigDecimal.ZERO;
      }
      return dividend.divide(divisor, 16, RoundingMode.HALF_UP).setScale(accuracy, RoundingMode.HALF_UP);
    }

    /**
     * @param f        .
     * @param s        .
     * @param accuracy   
     */
    public static BigDecimal multiply(BigDecimal f, BigDecimal s, int accuracy) {
      // 0 *     = 0
      if (isZeroDecimal(f) || isZeroDecimal(s)) {
        return BigDecimal.ZERO;
      }
      return f.multiply(s).setScale(accuracy, RoundingMode.HALF_UP);
    }

    /**
     *      
     *
     */
    public static BigDecimal pow(BigDecimal f, BigDecimal s) {
      //      Infinity    
      if (isZeroDecimal(f) && isDecimalLt(s, BigDecimal.ZERO)) {
        return BigDecimal.ZERO;
      }
      return new BigDecimal(String.valueOf(java.lang.Math.pow(f.doubleValue(), s.doubleValue())));
    }

    /**
     *      
     *
     */
    public static BigDecimal fraction(Fraction f) {
      long denominator = f.getDenominator();
      long numerator = f.getNumerator();
      return divide(new BigDecimal(String.valueOf(numerator)), new BigDecimal(String.valueOf(denominator)), 16);
    }

  }
}

package cn.zjcs.common.util;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author ..
 */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class NumberUtils {

  private static final Pattern DIGIT_PATTERN = Pattern.compile("[0-9]*");

  /**
   *       decimal      0
   *
   * @param decimal BigDecimal   
   * @return   0    true
   */
  public static boolean isZeroDecimal(BigDecimal decimal) {
    return decimal == null || decimal.compareTo(BigDecimal.ZERO) == 0;
  }

  /**
   *       decimal       0
   *
   * @param decimal BigDecimal   
   * @return    0    true
   */
  public static boolean isNotZeroDecimal(BigDecimal decimal) {
    return decimal != null && decimal.compareTo(BigDecimal.ZERO) != 0;
  }

  /**
   *             
   *
   * @param var    
   * @return       true
   */
  public static boolean isDigit(String var) {
    Matcher isNum = DIGIT_PATTERN.matcher(var);
    return isNum.matches();
  }

  public static boolean isEmptyNumber(Number number) {
    return number == null
            || number.intValue() == 0
            || number.longValue() == 0
            || number.doubleValue() == 0.00
            || number.byteValue() == 0
            || number.floatValue() == 0.0
            || number.shortValue() == 0;
  }

  public static boolean isNotEmptyNumber(Number number) {
    return !isEmptyNumber(number);
  }

  public static boolean isNotZeroLong(Long something) {
    if (something == null) {
      return false;
    }
    return !something.equals(0L);
  }
}