字符串-07-判断两个IP是否属于同一子网

1. 题目描述

IP地址是由4个0-255之间的整数构成的，用"."符号相连。
二进制的IP地址格式有32位，例如：10000011，01101011，00000011，00011000；每八位用十进制表示就是131.107.3.24
子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。
子网掩码与IP地址结构相同，是32位二进制数，由1和0组成，且1和0分别连续，其中网络号部分全为“1”和主机号部分全为“0”。
你可以简单的认为子网掩码是一串连续的1和一串连续的0拼接而成的32位二进制数，左边部分都是1，右边部分都是0。
利用子网掩码可以判断两台主机是否在同一子网中。
若两台主机的IP地址分别与它们的子网掩码进行逻辑“与”运算（按位与/AND）后的结果相同，则说明这两台主机在同一子网中。

示例：
I P 地址　 192.168.0.1
子网掩码　 255.255.255.0

转化为二进制进行运算：
I P 地址　 11000000.10101000.00000000.00000001
子网掩码　11111111.11111111.11111111.00000000

AND运算 11000000.10101000.00000000.00000000

转化为十进制后为：
192.168.0.0

I P 地址　 192.168.0.254
子网掩码　 255.255.255.0

转化为二进制进行运算：

I P 地址　11000000.10101000.00000000.11111110
子网掩码 11111111.11111111.11111111.00000000

AND运算 11000000.10101000.00000000.00000000

转化为十进制后为：
192.168.0.0

通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。

输入一个子网掩码以及两个ip地址，判断这两个ip地址是否是一个子网络。
若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2。

注:
有效掩码与IP的性质为：

1. 掩码与IP每一段在 0 - 255 之间
2. 掩码的二进制字符串前缀为网络号，都由‘1’组成；后缀为主机号，都由’0’组成

输入描述：
3行输入，第1行是输入子网掩码、第2，3行是输入两个ip地址
题目的示例中给出了三组数据，但是在实际提交时，你的程序可以只处理一组数据（3行）。

输出描述：
若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2

示例1：

输入
255.255.255.0
192.168.224.256
192.168.10.4
255.0.0.0
193.194.202.15
232.43.7.59
255.255.255.0
192.168.0.254
192.168.0.1
输出：
1
2
0
说明：
对于第一个例子:
255.255.255.0
192.168.224.256
192.168.10.4
其中IP:192.168.224.256不合法，输出1
对于第二个例子:
255.0.0.0
193.194.202.15
232.43.7.59
2个与运算之后，不在同一个子网，输出2
对于第三个例子，2个与运算之后，如题目描述所示，在同一个子网，输出0

2. 思路

要点：

1. 十进制数范围合法性
2. 掩码1、0连续性
3. 十进制转二进制，位的填充
4. AND运算，只有两个比较的位都为1，结果才为1，否则都是0
5. String比较值的大小用equals
6. char字符比较的是ASCII码值，如果要比较内容，需要加上''

3. 代码

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    while (in.hasNext()) {
        String[] split1 = in.next().split("\\.");
        String[] split2 = in.next().split("\\.");
        String[] split3 = in.next().split("\\.");

        //1.  判断范围合法性
        if (!isIllegal(split1) || !isIllegal(split2) || !isIllegal(split3)){
            System.out.println(1);
        }else {
            //2. 转为二进制
            String binary1 = toBinary(split1);
            String binary2 = toBinary(split2);
            String binary3 = toBinary(split3);
            //2.1 验证掩码的二进制是否合法
            if (!isBinaryIllegal(binary1)){
                System.out.println(1);
            }else {
                //3. AND运算
                String s1 = bitAND(binary1, binary2);
                String s2 = bitAND(binary1, binary3);

                //4. 比较值
                if (s1.equals(s2)){
                    System.out.println(0);
                }else {
                    System.out.println(2);
                }
            }
        }
    }
}

public static boolean isIllegal(String[] split){
    for (String s : split) {
        int value = Integer.parseInt(s);
        if (value < 0 || value > 255){
            return false;
        }
    }

    return true;
}

public static String toBinary(String[] sList){
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < sList.length; i++) {
        int value = Integer.parseInt(sList[i]);

        String binaryString = Integer.toBinaryString(value);
        String replace = String.format("%8s", binaryString).replace(' ', '0');

        if (i == sList.length - 1){
            builder.append(replace);
        }else {
            builder.append(replace).append(".");
        }
    }

    return builder.toString();
}

public static boolean isBinaryIllegal(String binary){
    String replace = binary.replace(".", "");
    char[] charArray = replace.toCharArray();

    boolean flag = false;
    for (int i = 0; i < charArray.length; i++) {
        if (charArray[i] == '0'){
            flag = true;//遇到了0
        }else {
            //遇到0了之后又遇到1
            if (charArray[i] == '1' && flag){
                return false;
            }
        }
    }
    return true;
}

public static String bitAND(String a, String b){
    String[] aSplit = a.split("\\.");
    String[] bSplit = b.split("\\.");

    StringBuilder result = new StringBuilder();

    for (int i = 0; i < aSplit.length; i++) {
        for (int j = 0; j < aSplit[i].length(); j++) {
            char re = aSplit[i].charAt(j) == '1' && bSplit[i].charAt(j) == '1' ? '1':'0';
            result.append(re);
        }
        result.append('.');
    }
    return result.toString();
}

以上为个人学习分享，如有问题，欢迎指出：）