识别有效的IP地址和掩码并进行分类统计

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    static String one2OneTwoSix = "([1-9]|[1-9][0-9]|1[01][0-9]|12[0-6])";
    static String zero2TwoFiveFive =
        "([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
    static String oneTwoEight2OneNightOne = "(1(2[89]|[3-8][0-9]|9[01]))";
    static String oneNightTwo2TwoTwoThree = "(19[2-9]|2[01][0-9]|22[0-3])";
    static String twoTwoFour2TwoThreeNight = "(22[4-9]|23[0-9])";
    static String twoFourZero2twoFiveFive = "(24[0-9]|25[0-5])";
    static String oneSix2ThreeOne = "(1[6-9]|2[0-9]|3[01])";
    static String A = "(" + one2OneTwoSix + ")(\\." + zero2TwoFiveFive + "){3}";
    static String B = "(" + oneTwoEight2OneNightOne + ")(\\." + zero2TwoFiveFive +
                      "){3}";
    static String C = "(" + oneNightTwo2TwoTwoThree + ")(\\." + zero2TwoFiveFive +
                      "){3}";
    static String D = "(" + twoTwoFour2TwoThreeNight + ")(\\." + zero2TwoFiveFive +
                      "){3}";
    static String E = "(" + twoFourZero2twoFiveFive + ")(\\." + zero2TwoFiveFive +
                      "){3}";
    static String PRIVATE =
        "10(\\." + zero2TwoFiveFive + "){3}|"
        + "172\\.(" + oneSix2ThreeOne + ")(\\." + zero2TwoFiveFive + "){2}|" +
        "192\\.168(\\." + zero2TwoFiveFive + "){2}";
    static String RIGHT = "(" + zero2TwoFiveFive + ")(\\." + zero2TwoFiveFive +
                          "){3}";
    static String one = "0|128|192|224|240|248|252|254";
    static String MASK =
        "(" + one + ")(\\.0){3}|" +
        "255\\.(" + one + ")(\\.0){2}|" +
        "(255\\.){2}(" + one + ")\\.0|" +
        "(255\\.){3}(" + one + ")";

    static Pattern patternMask = Pattern.compile(MASK);
    static String OTHER = "(0|127)(\\.\\d*){3}";
    static Pattern patternOther = Pattern.compile(OTHER);

    static Pattern[] patterns = {Pattern.compile(A), Pattern.compile(B), Pattern.compile(C), Pattern.compile(D), Pattern.compile(E), null, Pattern.compile(PRIVATE)};
    static Pattern patternRight = Pattern.compile(RIGHT);

    public static void main(String[] args) {
        int[] count = new int[7];
        Scanner in = new Scanner(System.in);

        while (in.hasNextLine()) {
            String line = in.nextLine();
            count(line, count);
        }
        for (int i : count) {
            System.out.print(i + " ");
        }
    }
    private static void count(String s, int[] count) {
        String[] split = s.split("~");
        String ip = split[0];
        String mask = split[1];
        Matcher matcherOther = patternOther.matcher(ip);
        if (matcherOther.matches()) {
            return;
        }
        Matcher matcherIp = patternRight.matcher(ip);
        Matcher matcherMask = patternMask.matcher(mask);
        if (!matcherIp.matches() || !matcherMask.matches()) {
            count[5]++;
            return;
        }
        for (int i = 0; i < patterns.length; i++) {
            Pattern pattern = patterns[i];
            if (pattern == null) {
                continue;
            }
            if (pattern.matcher(ip).matches()) {
                count[i]++;
            }
        }

    }

 }

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int aCnt = 0, bCnt = 0, cCnt = 0, dCnt = 0, eCnt = 0, errCnt = 0, privateCnt = 0;
        while (in.hasNextLine()) { // 注意 while 处理多个 case'
            String inputLine = in.nextLine();
            if (inputLine.isEmpty()) break;
            //处理读入的ip地址
            String[] items = inputLine.split("~");
            String ip = items[0];
            String mask = items[1];
            //跳过不属于任何类型的ip
            if (isFmtValid(ip) && (ip.startsWith("0.") || ip.startsWith("127."))) continue;
            if (!isMaskValid(mask) || !isIpValid(ip)) {
                errCnt++;
                continue;
            }
            //判断ip的类型
            Long ipLongVal = getIpLongVal(ip);
            if ((ipLongVal >= getIpLongVal("10.0.0.0") && ipLongVal <= getIpLongVal("10.255.255.255")) ||
                (ipLongVal >= getIpLongVal("172.16.0.0") && ipLongVal <= getIpLongVal("172.31.255.255")) ||
                (ipLongVal >= getIpLongVal("192.168.0.0") && ipLongVal <= getIpLongVal("192.168.255.255"))) {
                privateCnt++;
            }
            if ((ipLongVal >= getIpLongVal("1.0.0.0") && ipLongVal <= getIpLongVal("126.255.255.255"))) {
                aCnt++;
            } else if ((ipLongVal >= getIpLongVal("128.0.0.0") && ipLongVal <= getIpLongVal("191.255.255.255"))) {
                bCnt++;
            } else if ((ipLongVal >= getIpLongVal("192.0.0.0") && ipLongVal <= getIpLongVal("223.255.255.255"))) {
                cCnt++;
            } else if ((ipLongVal >= getIpLongVal("224.0.0.0") && ipLongVal <= getIpLongVal("239.255.255.255"))) {
                dCnt++;
            } else if ((ipLongVal >= getIpLongVal("240.0.0.0") && ipLongVal <= getIpLongVal("255.255.255.255"))) {
                eCnt++;
            }
        }
        System.out.println(aCnt + " " + bCnt + " " + cCnt + " " + dCnt + " " + eCnt + " " + errCnt + " " + privateCnt);
    }
    public static boolean isIpValid(String ip) {
        //格式非法
        return isFmtValid(ip);
    }

    public static Long getIpLongVal(String ip) {
        String[] ipItems = ip.split("\\.");
        Long ipLongVal = 0L;
        for (int i = 0; i < ipItems.length; i++) {
            Long posVal = Long.valueOf(ipItems[i]);
            //计算得到掩码的10进制值
            ipLongVal += (posVal << 8 * (3 - i));
        }
        return ipLongVal;
    }

    //判断ip或掩码格式是否合法
    public static boolean isFmtValid(String ip) {
        String[] ipItems = ip.split("\\.");
        if (ipItems.length != 4) {
            return false;
        } else {
            for (int i = 0; i < ipItems.length; i++) {
                if (!isInteger(ipItems[i]) ||
                        Integer.valueOf(ipItems[i]) > 255 ||
                        Integer.valueOf(ipItems[i]) < 0) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean isMaskValid(String mask) {
        //格式非法
        if (!isFmtValid(mask)) return false;
        //格式合法，判断掩码是否合法
        String[] maskItems = mask.split("\\.");
        Long maskVal = getIpLongVal(mask);
        //全0或全1的情况非法
        if (maskVal == 0L || maskVal == ((1L << 32) - 1)) {
            return false;
        }
        maskVal = maskVal << 32;//将计算得到的掩码移到高32位
        if (maskVal > 0) return false;
        //左移32次，如果出现大于0的数，则非法
        for (int i = 0; i < 32; i++) {
            maskVal = maskVal << 1;
            if (maskVal > 0) return false;
        }
        return true;
    }

    public static boolean isInteger(String str) {
        boolean isInt = false;
        try {
            Integer.valueOf(str);
            isInt = true;
        } catch (NumberFormatException e) {
            isInt = false;
        }
        return isInt;
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
  
        testCheckIp();
    }

    public static void testCheckIp() {
        Scanner in = new Scanner(System.in);
        int aNum = 0;
        int bNum = 0;
        int cNum = 0;
        int dNum = 0;
        int eNum = 0;
        int errNum = 0;
        int pNum = 0;
        List<String> errIp = new ArrayList<>();
      /*
        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
         */
        while (in.hasNextLine()) {
            String ipStr = in.nextLine();
            String[] ipArr = ipStr.split("~");

            int firstIp = getIpSeq(ipArr[0], 0);
            if (firstIp == 0 || firstIp == 127) {
                continue;
            }
            if (ipIsInvalid(ipArr[0])) {
                errNum++;
                errIp.add(ipArr[0]);
                continue;
            }

            if (maskIsInvalid(ipArr[1])) {
                errNum++;
                errIp.add(ipArr[1]);
                continue;
            }

            if (firstIp >= 1 && firstIp <= 126) {
                aNum++;
            }
            if (firstIp >= 128 && firstIp <= 191) {
                bNum++;
            }
            if (firstIp >= 192 && firstIp <= 223) {
                cNum++;
            }
            if (firstIp >= 224 && firstIp <= 239) {
                dNum++;
            }
            if (firstIp >= 240 && firstIp <= 255) {
                eNum++;
            }
            int secIp = getIpSeq(ipArr[0], 1);
            if (firstIp == 10 || (firstIp == 172 && secIp >= 16 && secIp <= 31) || (firstIp == 192 && secIp == 168)) {
                pNum++;
            }


        }
        System.out.println(aNum + " " + bNum + " " + cNum + " " + dNum + " " + eNum + " " + errNum + " " + pNum);
    }

    private static boolean ipIsInvalid(String ip) {
        /**
         * 第一部分：匹配3个0~255.（注意后面的一个点）（重复匹配3次）
         * 第二部分：匹配最后的数字0~255
         */
        String regex = "((1[0-9][0-9]\\.)|(2[0-4][0-9]\\.)|(25[0-5]\\.)|([1-9][0-9]\\.)|([0-9]\\.)){3}((1[0-9][0-9])|(2[0-4][0-9])|(25[0-5])|([1-9][0-9])|([0-9]))";
        return !ip.matches(regex);
    }

    private static boolean maskIsInvalid(String maskIp) {
        String regex = "(255.0.0.0)|(255.255.0.0)|(255.255.255.0)";
        return !maskIp.matches(regex);
    }

    private static int getIpSeq(String ip, int index) {
        String[] ipArr = ip.split("\\.");
        return Integer.parseInt(ipArr[index]);
    }
}

import java.util.Scanner;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int cntA = 0;
        int cntB = 0;
        int cntC = 0;
        int cntD = 0;
        int cntE = 0;
        int cntError = 0;
        int cntPrivate = 0;
        while (in.hasNext()) { // 注意 while 处理多个 case
            String a = in.next();
            String[] aa = a.split("~");
            if(aa.length != 2) {
                cntError++;
                continue;
            }
            if(aa[0].startsWith("0.") || aa[0].startsWith("127.")) {
                continue;
            }
            long[] ips = splitIp(aa[0]);
            long[] masks = splitIp(aa[1]);
            if(ips == null || masks == null) {
                cntError++;
                continue;
            }
            //校验掩码
            long maskValue = (masks[0] << 24) + (masks[1] << 16) + (masks[2] << 8) + masks[3];
            String maskBinary = Long.toBinaryString(maskValue);
            if(maskBinary.length() != 32 || !maskBinary.matches("^1{1,}0{1,}$")) {
                cntError++;
                continue;
            }
            long ipValue = (ips[0] << 24) + (ips[1] << 16) + (ips[2] << 8) + ips[3];
            if(ipValue >= 1l << 24 && ipValue < 127l << 24) {
                cntA++;
                //System.out.println(aa[1]);
                if(ips[0] == 10) {
                    cntPrivate++;
                }
            }else if(ipValue >= (128l << 24) && ipValue < (192l << 24)) {
                cntB++;
                if(ipValue >= (172l << 24) + (16l << 16) && ipValue < (172l << 24) + (32l << 8)) {
                    cntPrivate++;
                }
            }else if(ipValue >= (192l << 24) && ipValue < (224l << 24)) {
                cntC++;
                if(ips[0] == 192l && ips[1] == 168l) {
                    cntPrivate++;
                }
            }else if(ipValue >= (224l << 24) && ipValue < (240l << 24)) {
                cntD++;
            }else if(ipValue >= (240l << 24) && ipValue < (256l << 24)) {
                cntE++;
            }else{
                //cntError++;
            }
        }
        System.out.println(cntA + " " + cntB + " " + cntC + " " + cntD + " " + cntE + " " + cntError + " " + cntPrivate);
    }
    public static long[] splitIp(String ip) {
        String[] ips = ip.split("\\.");
        long[] res = new long[4];
        if(ips.length != 4) {
            return null;
        }
        for(int i = 0; i < ips.length; i++) {
            try {
                Integer ii = Integer.valueOf(ips[i]);
                if(ii < 0 || ii > 255) {
                    return null;
                }
                if(i == 0 && (ii == 0 || ii == 127)) {
                    return null;
                }
                res[i] = ii;
            }catch(Exception e) {
                return null;
            }
        }
        return res;
    }
}

• 将输入的 IP 和掩码转化为 long 类型以做进一步操作
• 优先判断是否需要忽略
• 位运算验证 IP，掩码合法性并计数
• 直接范围比较A, B, C, D, E 以及私网 IP 的范围并计数

import java.util.Scanner;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        List<String> inputs = new ArrayList<String>();
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            inputs.add(in.nextLine());
        }

        int[] results = statisticIP(inputs);
        for (int v : results) {
            System.out.printf("%d ",v);
        }
    }

    private static int[] statisticIP(List<String> ips) {
        int[] counter = new int[7];

        for (String addr : ips) {
            String[] addrMasks = addr.split("~");
            long ip = parseAddr(addrMasks[0]);
            long mask = parseAddr(addrMasks[1]);

            if (needIgnore(ip)) {
                continue;
            }

            if (!validIp(ip)) {
                counter[5] ++;
                continue;
            }

            if (!validMask(mask)) {
                counter[5] ++;
                continue;
            }

            if (isA(ip)) {
                counter[0] ++;          
            }

            if (isB(ip)) {
                counter[1] ++;
            }

            if (isC(ip)) {
                counter[2] ++;
            }

            if (isD(ip)) {
                counter[3] ++;
            }

            if (isE(ip)) {
                counter[4] ++;
            }

            if (isPrivate(ip)) {
                counter[6] ++;
            }
        }

        return counter;
    }

    static boolean needIgnore(long ip) {
        return (ip >> 24 ) == 127 || (ip >> 24) == 0;
    }

    static boolean isA(long ip) {
        long begin = parseAddr("1.0.0.0");
        long end = parseAddr("126.255.255.255");
        return ip >= begin && ip <= end;
    }

    static boolean isB(long ip) {
        long begin = parseAddr("128.0.0.0");
        long end = parseAddr("191.255.255.255");
        return ip >= begin && ip <= end;
    }

    static boolean isC(long ip) {
        long begin = parseAddr("192.0.0.0");
        long end = parseAddr("223.255.255.255");
        return ip >= begin && ip <= end;
    }

    static boolean isD(long ip) {
        long begin = parseAddr("224.0.0.0");
        long end = parseAddr("239.255.255.255");
        return ip >= begin && ip <= end;

    }
    static boolean isE(long ip) {
        long begin = parseAddr("240.0.0.0");
        long end = parseAddr("255.255.255.255");
        return ip >= begin && ip <= end;
    }

    static boolean isPrivate(long ip) {
        return ip >= parseAddr("10.0.0.0") && ip <= parseAddr("10.255.255.255") ||
        ip >= parseAddr("172.16.0.0") && ip <= parseAddr("172.31.255.255") ||
        ip >= parseAddr("192.168.0.0") && ip <= parseAddr("192.168.255.255") ;
    }

    static boolean validIp(long ip) {
        return ip != -1;
    }

    static boolean validMask(long mask) {
        if (mask == -1) {
            return false;
        }

        if (mask == 0 || (mask & (mask + 1)) == 0) {
            return false;
        }
        
        while ((1L & mask) == 0) {
            mask >>= 1;
        }

        return (mask & (mask + 1)) == 0;
    }

    static long parseAddr(String addr) {
        String[] part = addr.split("\\.");
        if (part.length != 4) {
            return -1;
        }

        long addrVal = 0L;
        for (int i = 0; i < part.length; i++) {
            try {
                int partInt = Integer.parseInt(part[i]);
                addrVal |= partInt;
                if (i < part.length - 1) {
                    addrVal <<= 8;
                }
            } catch (Exception e) {
                return -1;
            }
        }

        return addrVal;
    }
}