Java 子网计算器：自动划分网络子网

本程序使用 Java 实现了一个简单的子网计算器，可以根据输入的网络地址、子网掩码和每个子网所需的主机数，自动计算出可以划分的子网数量、每个子网的地址、子网掩码和每个子网可以容纳的最大主机数量。

程序代码

import java.util.Scanner;

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

        System.out.print("Enter network address: ");
        String networkAddress = scanner.nextLine();

        System.out.print("Enter subnet mask: ");
        String subnetMask = scanner.nextLine();

        System.out.print("Enter number of hosts per subnet: ");
        int hostsPerSubnet = scanner.nextInt();

        int subnetBits = calculateSubnetBits(hostsPerSubnet);
        int subnets = (int) Math.pow(2, subnetBits);

        System.out.println("Number of subnets: " + subnets);

        String[] networkAddressParts = networkAddress.split("\\.");
        String[] subnetMaskParts = subnetMask.split("\\.");

        int[] networkAddressInt = new int[4];
        int[] subnetMaskInt = new int[4];

        for (int i = 0; i < 4; i++) {
            networkAddressInt[i] = Integer.parseInt(networkAddressParts[i]);
            subnetMaskInt[i] = Integer.parseInt(subnetMaskParts[i]);
        }

        int[] subnetAddressInt = calculateSubnetAddress(networkAddressInt, subnetMaskInt, subnetBits);
        String[] subnetAddressParts = new String[4];

        for (int i = 0; i < 4; i++) {
            subnetAddressParts[i] = String.valueOf(subnetAddressInt[i]);
        }

        System.out.println("Subnet address: " + String.join(".", subnetAddressParts));

        String[] subnetMaskBinaryParts = calculateSubnetMaskBinary(subnetMaskInt);
        String[] subnetMaskBinaryPartsModified = modifySubnetMaskBinary(subnetMaskBinaryParts, subnetBits);

        String[] subnetMaskPartsModified = new String[4];

        for (int i = 0; i < 4; i++) {
            subnetMaskPartsModified[i] = Integer.toString(Integer.parseInt(subnetMaskBinaryPartsModified[i], 2));
        }

        System.out.println("Subnet mask: " + String.join(".", subnetMaskPartsModified));

        int maxHostsPerSubnet = (int) Math.pow(2, 32 - subnetBits) - 2;
        System.out.println("Maximum hosts per subnet: " + maxHostsPerSubnet);
    }

    public static int calculateSubnetBits(int hostsPerSubnet) {
        int subnetBits = 0;

        while (Math.pow(2, subnetBits) - 2 < hostsPerSubnet) {
            subnetBits++;
        }

        return subnetBits;
    }

    public static int[] calculateSubnetAddress(int[] networkAddressInt, int[] subnetMaskInt, int subnetBits) {
        int[] subnetAddressInt = new int[4];

        for (int i = 0; i < 4; i++) {
            subnetAddressInt[i] = networkAddressInt[i] & subnetMaskInt[i];
        }

        int hostBits = 32 - subnetBits;

        if (hostBits > 0) {
            int subnetNumber = (int) Math.pow(2, hostBits);
            subnetAddressInt[3] = subnetAddressInt[3] - subnetAddressInt[3] % subnetNumber;
        }

        return subnetAddressInt;
    }

    public static String[] calculateSubnetMaskBinary(int[] subnetMaskInt) {
        String[] subnetMaskBinaryParts = new String[4];

        for (int i = 0; i < 4; i++) {
            subnetMaskBinaryParts[i] = Integer.toBinaryString(subnetMaskInt[i]);
            subnetMaskBinaryParts[i] = String.format("%8s", subnetMaskBinaryParts[i]).replace(" ", "0");
        }

        return subnetMaskBinaryParts;
    }

    public static String[] modifySubnetMaskBinary(String[] subnetMaskBinaryParts, int subnetBits) {
        String[] subnetMaskBinaryPartsModified = subnetMaskBinaryParts.clone();
        int fullBytes = subnetBits / 8;

        for (int i = fullBytes; i < 4; i++) {
            subnetMaskBinaryPartsModified[i] = "00000000";
        }

        int remainingBits = subnetBits % 8;

        if (remainingBits > 0) {
            String modifiedByte = subnetMaskBinaryPartsModified[fullBytes].substring(0, remainingBits) + subnetMaskBinaryPartsModified[fullBytes].substring(remainingBits).replaceAll("1", "0");
            subnetMaskBinaryPartsModified[fullBytes] = modifiedByte;
        }

        return subnetMaskBinaryPartsModified;
    }
}

程序功能

输入网络地址、子网掩码和每个子网所需的主机数
自动计算可以划分的子网数量
计算每个子网的地址
计算每个子网的子网掩码
计算每个子网可以容纳的最大主机数量

程序说明

程序使用 Scanner 类从用户输入获取网络地址、子网掩码和主机数。
使用 calculateSubnetBits 方法计算出所需的子网位数。
使用 Math.pow 方法计算出子网数目。
将网络地址和子网掩码转换为整数数组，以便进行位运算。
使用 calculateSubnetAddress 方法计算出每个子网的网段地址。
使用 calculateSubnetMaskBinary 方法将子网掩码转换为二进制字符串数组，并使用 modifySubnetMaskBinary 方法修改子网掩码以匹配所需的子网位数。
使用 Math.pow 方法计算出每个子网可以容纳的最大主机数。

注意

程序假设输入的网络地址、子网掩码和主机数目是有效的。
程序仅提供了基本的功能，实际应用中可能需要考虑更多因素，例如网络拓扑结构、路由协议等。

本程序仅供参考，实际应用中可能需要根据具体需求进行调整和修改。