Java判断字符串是否为IP地址的方法

java 判断字符串是否为ip地址，供大家参考，具体内容如下

1、代码

主要就是这么几个条件

• 非空
• 长度符合 0.0.0.0 - 255.255.255.255
• 包含分隔符 且 个数正确
• 四个全部是数字，且都在合理的范围内
  

 /**
 * 判断某个字符串是否是一个 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;
}

2、commonutils 工具类

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>
 * 比如 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);
 }

 }
}

3、numberutils 工具类

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);
 }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。