Java 检查IPv4地址是否有效

我试图用Java编写一个基本程序，检查IP地址是否有效。除了Scanner类，我尝试不使用任何外部类，也不使用正则表达式

我的代码，可用于接收4个整数作为输入，每个八位字节一个。我还有一本书，它比第一本书可读性更强，但篇幅更长

---

我的问题是，有没有其他方法可以用更少的行来实现这个想法，如果是的话，我将如何实现呢？

只有一些小的改进（我认为你的代码看起来非常好-我的观点是到目前为止），阅读起来很清楚，所有的工作块都可以正确理解

boolean isFailed = false;
if (first < 0 || first > 255) {
    System.out.println("Octet 1 is invalid");
    isFailed = true;
}
if (second < 0 || second > 255) {
    System.out.println("Octet 2 is invalid");
    isFailed = true;
}
if (third < 0 || third > 255) {
    System.out.println("Octet 3 is invalid");
    isFailed = true;
}
if (fourth < 0 || fourth > 255) {
    System.out.println("Octet 4 is invalid");
    isFailed = true;
}

if (!isFailed){
    System.out.println("IP Address: " + first + "." + second + "." + third + "." + fourth);
}

boolean isFailed=false；
如果（第一个<0 | |第一个>255）{
System.out.println（“八位组1无效”）；
isFailed=true；
}
如果（秒<0 | |秒>255）{
System.out.println（“八位组2无效”）；
isFailed=true；
}
如果（第三个<0 | |第三个>255）{
System.out.println（“八位组3无效”）；
isFailed=true；
}
如果（第四个<0 | |第四个>255）{
System.out.println（“八位字节4无效”）；
isFailed=true；
}
如果（！isFailed）{
System.out.println（“IP地址：+first+”+second+“+third+”+fourth）；
}

---

所以我简单地颠倒了打印顺序-这只为您节省了之前的那张大支票

您的方法是可以检查每个八位组

您可以简单地执行4次，或为此编写一个方法：

private static boolean check(int octet, int index){
    if (0xFF & octet < 256) return true;
    System.out.println("Octet "+index+" is invalid";
    return false;
}

注意-这只显示第一个无效的八位字节-如果要检查所有内容，需要另一个布尔值

boolean result = check(first,0) && 
    check (second, 2) && 
    check (third, 3) && 
    check(fourth, 4); //reveals all errors

一种完全不同的方法是使用

但是这也没有提供关于八位组的信息，这是无效的

---

（顺便问一下，您的代码有什么问题吗？很好，真的！）

虽然这个代码段有点冗长，但它很简单，可以自我描述，并且已经证明很紧凑

private static boolean isIPAddressValid(String ip) {    
    boolean result = true;
    int i = 0;
    int [] val = new int[4];

    if ((ip == null) || (ip.trim().length() == 0))
    {
        //null ip address entered
        result = false;
    }
    else
    {
        if (!(ip.contains(".")))
        {
            //no '.' found
            result = false;
        }
        else
        {
            String [] parts = ip.split("\\.");
            if (!(parts.length == 4))
            {
                //not 4 quadrants
                result = false;
            }
            else
            {
                for (String s : parts) { 
                    try {
                        val[i] = Integer.parseInt(s);
                        if ((val[i] < 0) || (val[i] > 255))
                        {
                            //this quadrant's value exceeds limits
                            result = false;
                        }
                        i++;
                    } catch (Exception e) {
                        //failed to parse quadrant to an integer");
                        result = false;
                    }
                }
            }
        }
    }
    return result;
}

private静态布尔值有效（字符串ip）{
布尔结果=真；
int i=0；
int[]val=新的int[4]；
如果（（ip==null）| |（ip.trim（）.length（）=0））
{
//输入的ip地址为空
结果=假；
}
其他的
{
如果（！（ip.包含（“.”））
{
//找不到“.”
结果=假；
}
其他的
{
String[]parts=ip.split（“\\”）；
如果（！（parts.length==4））
{
//不是四象限
结果=假；
}
其他的
{
对于（字符串s:parts）{
试一试{
val[i]=整数.parseInt（s）；
if（（val[i]<0）|（val[i]>255））
{
//此象限的值超出限制
结果=假；
}
i++；
}捕获（例外e）{
//无法将象限分析为整数“）；
结果=假；
}
}
}
}
}
返回结果；
}

我只是觉得无聊，写了这个regexp

public static boolean isValid(String ip) {
    boolean isvalid;

    isvalid = ip.matches(
            "(([0-9]|[0-9]{0,2}|1[0-9]*{0,2}|2[0-5][0-5]|0{0,3}).){3}" +
             "([0-9]|[0-9]{0,2}|1[0-9]*{0,2}|2[0-5][0-5]|0{0,3})"
    );

    return isvalid;
}

并在以下数据集上进行了测试：

String[] ips = {
        "0.0.0.0",
        "0.111.222.0",
        "0.0.0.000",
        "0.00.0.000",
        "1.1.1.1",
        "2.2.2.2",
        "12.13.14.15",
        "29.29.29.29",
        "99.99.000.1",
        "111.102.144.190",
        "255.255.199.199",
        "266.255.255.255", //inv
        "255.265.255.255", //inv 
        "255.255.258.255", //inv 
        "255.255.255.259", //inv 
        "299.100.110.255" //inv
    };
    for (String s : ips) {
        if (isValid(s) == false) {
            System.err.println(s + " is invalid");
        }
    }

---

你可以把整根绳子收进去，用“线”分开。，确保数组的长度为4，然后循环数组中的每个项并验证它是否为合法的八位字节。但一般来说，我认为您可以通过循环4次来解决当前代码，每次循环扫描一个八位元，验证，如果验证失败，则下注。删除大量代码重复。我打赌您可以使用for循环。看起来确实有很多相似的重复代码。我尝试使用for循环，但在尝试为每个八位字节声明变量时遇到了问题。我需要4个不同的变量（每个八位字节），那么我如何在循环中声明它们呢？@Kootling在循环外声明它们，并在每次迭代中使用其中一个。您可以检查迭代器的值以知道使用哪个变量。我不明白这与我发布的第二个要点（）有什么不同。这段代码不是只是在我的原始代码中切换布尔值吗？如果（first>=0&&first=0&&second=0&&second=0&&second=0&&second=0&&second=0&&second=4，它就没有这部分

public static boolean isValid(String ip) {
    boolean isvalid;

    isvalid = ip.matches(
            "(([0-9]|[0-9]{0,2}|1[0-9]*{0,2}|2[0-5][0-5]|0{0,3}).){3}" +
             "([0-9]|[0-9]{0,2}|1[0-9]*{0,2}|2[0-5][0-5]|0{0,3})"
    );

    return isvalid;
}

String[] ips = {
        "0.0.0.0",
        "0.111.222.0",
        "0.0.0.000",
        "0.00.0.000",
        "1.1.1.1",
        "2.2.2.2",
        "12.13.14.15",
        "29.29.29.29",
        "99.99.000.1",
        "111.102.144.190",
        "255.255.199.199",
        "266.255.255.255", //inv
        "255.265.255.255", //inv 
        "255.255.258.255", //inv 
        "255.255.255.259", //inv 
        "299.100.110.255" //inv
    };
    for (String s : ips) {
        if (isValid(s) == false) {
            System.err.println(s + " is invalid");
        }
    }