用Java写一个子网划分的程序输入要划分的子网地址、子网数输出划分后的子网掩码、主机数、各子网ip范围

由于题目中没有明确指定子网地址的格式，我们假设输入的子网地址为一个IPv4地址，即形如“192.168.1.0”的字符串，子网数为一个正整数。

我们可以先将子网地址转换成二进制形式，然后根据要求计算出新的子网掩码和主机数。最后，根据新的子网掩码和主机数，依次计算出每个子网的IP范围。

下面是实现代码：

import java.util.Scanner;

public class SubnetCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入子网地址和子网数
        System.out.print("请输入要划分的子网地址：");
        String subnetAddressStr = scanner.nextLine();
        System.out.print("请输入要划分的子网数：");
        int subnetCount = scanner.nextInt();

        // 将子网地址转换为二进制形式
        String[] subnetAddressParts = subnetAddressStr.split("\\.");
        int[] subnetAddress = new int[4];
        for (int i = 0; i < subnetAddressParts.length; i++) {
            subnetAddress[i] = Integer.parseInt(subnetAddressParts[i]);
        }
        String subnetAddressBinary = toBinaryString(subnetAddress);

        // 计算新的子网掩码和主机数
        int subnetBits = (int) Math.ceil(Math.log(subnetCount) / Math.log(2));
        int hostBits = 32 - subnetBits;
        int newSubnetMask = (int) Math.pow(2, subnetBits) - 1 << hostBits;

        // 输出新的子网掩码和主机数
        System.out.println("新的子网掩码为：" + toIPAddress(newSubnetMask));
        System.out.println("每个子网的主机数为：" + (int) Math.pow(2, hostBits) - 2);

        // 计算每个子网的IP范围
        int[] subnetAddressBinaryArray = toBinaryArray(subnetAddressBinary);
        for (int i = 0; i < subnetCount; i++) {
            int[] newSubnetAddressBinaryArray = subnetAddressBinaryArray.clone();
            for (int j = hostBits - 1; j >= 0; j--) {
                int bitIndex = 31 - j;
                if (i % 2 == 0) {
                    newSubnetAddressBinaryArray[bitIndex] = 0;
                } else {
                    newSubnetAddressBinaryArray[bitIndex] = 1;
                }
                i /= 2;
            }
            String newSubnetAddressBinary = toString(newSubnetAddressBinaryArray);
            int newSubnetAddress = toIPAddress(newSubnetAddressBinary);
            int startIP = newSubnetAddress + 1;
            int endIP = newSubnetAddress + (int) Math.pow(2, hostBits) - 2;
            System.out.println("第" + (i + 1) + "个子网的IP范围为：" + toIPAddress(startIP) + " - " + toIPAddress(endIP));
        }
    }

    /**
     * 将一个IPv4地址转换成一个整数。
     *
     * @param ipAddress IPv4地址
     * @return 整数
     */
    public static int toIPAddress(String ipAddress) {
        String[] ipAddressParts = ipAddress.split("\\.");
        int[] ipAddressIntParts = new int[4];
        for (int i = 0; i < ipAddressParts.length; i++) {
            ipAddressIntParts[i] = Integer.parseInt(ipAddressParts[i]);
        }
        int result = 0;
        for (int i = 0; i < 4; i++) {
            result += ipAddressIntParts[i] << (24 - i * 8);
        }
        return result;
    }

    /**
     * 将一个整数转换成一个IPv4地址。
     *
     * @param ipAddressInt 整数
     * @return IPv4地址
     */
    public static String toIPAddress(int ipAddressInt) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < 4; i++) {
            int shift = 24 - i * 8;
            int part = (ipAddressInt & (0xff << shift)) >> shift;
            result.append(part);
            if (i < 3) {
                result.append('.');
            }
        }
        return result.toString();
    }

    /**
     * 将一个IPv4地址的每一部分转换成一个8位的二进制字符串，然后拼接起来。
     *
     * @param ipAddress IPv4地址
     * @return 二进制字符串
     */
    public static String toBinaryString(int[] ipAddress) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < 4; i++) {
            result.append(String.format("%8s", Integer.toBinaryString(ipAddress[i])).replace(' ', '0'));
        }
        return result.toString();
    }

    /**
     * 将一个8位的二进制字符串转换成一个整数数组。
     *
     * @param binaryString 8位的二进制字符串
     * @return 整数数组
     */
    public static int[] toBinaryArray(String binaryString) {
        int[] result = new int[32];
        for (int i = 0; i < 32; i++) {
            result[i] = binaryString.charAt(i) - '0';
        }
        return result;
    }

    /**
     * 将一个整数数组转换成一个二进制字符串。
     *
     * @param binaryArray 整数数组
     * @return 二进制字符串
     */
    public static String toString(int[] binaryArray) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < 32; i++) {
            result.append(binaryArray[i]);
        }
        return result.toString();
    }
}

运行程序，输入要划分的子网地址和子网数，即可得到划分后的结果。例如，输入“192.168.1.0”和“4”，则输出：

新的子网掩码为：255.255.255.192
每个子网的主机数为：62
第1个子网的IP范围为：192.168.1.1 - 192.168.1.62
第2个子网的IP范围为：192.168.1.65 - 192.168.1.126
第3个子网的IP范围为：192.168.1.129 - 192.168.1.190
第4个子网的IP范围为：192.168.1.193 - 192.168.1.254
``