IP地址和子网掩码的分类统计

一道特别恶心的字符串处理题。

问题描述：

请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址1.0.0.0~126.255.255.255;

B类地址128.0.0.0~191.255.255.255;

C类地址192.0.0.0~223.255.255.255;

D类地址224.0.0.0~239.255.255.255；

E类地址240.0.0.0~255.255.255.255

私网IP范围是：

10.0.0.0～10.255.255.255

172.16.0.0～172.31.255.255

192.168.0.0～192.168.255.255

子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）

注意二进制下全是1或者全是0均为非法

注意：

1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时可以忽略

2. 私有IP地址和A,B,C,D,E类地址是不冲突的

解决方案：

首先一个很直观的思路是先判断IP地址和子网掩码是否合法，只对合法的地址进一步分析。

然后就是先属于哪类公网ip，再判断是否为私网ip。

public class Main{
    static int[][] pubAddress = {{1,126},{128, 191},{192, 223},{224, 239}, {240, 255}};
    static int[][] priAddress = {{10,0,0,0,10,255,255,255},
                                 {172,16,0,0,172,31,255,255},
                                 {192,168,0,0,192,168,255,255}}; 
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int[] result = new int[7];
        while(in.hasNext()){
            process(result, in.nextLine());
        }
        for(int i = 0; i < result.length - 1; i++){
            System.out.print(result[i] + " ");
        }
        System.out.println(result[result.length - 1]);
    }
    public static void process(int[] result , String str){
        String[] array = str.split("~");
        String[] ip = array[0].split("\\.");
        String[] mask = array[1].split("\\.");
        String regex = "[0-9]+";
        if(ip.length < 4 || mask.length < 4){
            result[5]++;
            return;
        }
        // ip出错是值不为数字或者超出255
        for(String item : ip){
            if(!item.matches(regex) || Integer.valueOf(item) > 255){
                result[5]++;
                return;
            }
        }
        if(!mask(mask)){
            result[5]++;
            return;            
        }
        int[] ipArray = new int[4];
        for(int i = 0; i < ip.length; i++){
            ipArray[i] = Integer.valueOf(ip[i]);
        }
        //先判断共有地址
        for(int i = 0; i < pubAddress.length; i++){
            if(ipArray[0] >= pubAddress[i][0] && ipArray[0] <= pubAddress[i][1]){
                result[i]++;
                break;
            }
        }
        //再判断私有地址
        for(int i = 0; i < priAddress.length; i++){
            boolean flag = true;
            for(int j = 0; j < ipArray.length; j++){
                if(ipArray[j] < priAddress[i][j] || ipArray[j] > priAddress[i][j + 4]){
                    flag = false;
                    break;
                }
            }
            if(flag){
                result[6]++;
                break;
            }
        }
    }
    public static boolean mask(String[] mask){ //判断子网掩码是否合法
        String regex = "[0-9]+";
        StringBuilder sb = new StringBuilder();
        for(String item : mask){
            if(!item.matches(regex) || Integer.valueOf(item) > 255){
                return false;
            }
            String bin = Integer.toBinaryString(Integer.valueOf(item));
            for(int i = 0; i < 8 - bin.length(); i++){
                sb.append(0);
            }
            sb.append(bin);
        }
        int i = 0;
        for(; i < sb.length(); i++){
            if(sb.charAt(i) == '0'){
                break;
            }
        }
        for(; i < sb.length(); i++){
            if(sb.charAt(i) == '1'){
                return false;
            }
        }
        if(sb.charAt(0) == '0' || sb.charAt(sb.length() - 1) == '1'){ //处理全0全1
            return false;
        }
        return true;
    }
}