1import java.util.*;
                      2import java.util.regex.Pattern;
                      3import java.util.regex.Matcher;
                      4
                      5/**
                      6 * 子网划分工具 - Java版本
                      7 * 支持VLSM可变长子网掩码、子网合并、超网计算、网络规划等功能
                      8 */
                      9public class SubnetCalculator {
                     10    private static final Pattern IP_PATTERN = Pattern.compile("^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
                     11    private static final Pattern CIDR_PATTERN = Pattern.compile("^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\/([0-9]|[1-2][0-9]|3[0-2])$");
                     12
                     13    // 子网需求类
                     14    public static class SubnetRequirement {
                     15        private String name;
                     16        private int hosts;
                     17
                     18        public SubnetRequirement(String name, int hosts) {
                     19            this.name = name;
                     20            this.hosts = hosts;
                     21        }
                     22
                     23        public String getName() { return name; }
                     24        public int getHosts() { return hosts; }
                     25    }
                     26
                     27    // 部门需求类
                     28    public static class DepartmentRequirement {
                     29        private String name;
                     30        private int size;
                     31
                     32        public DepartmentRequirement(String name, int size) {
                     33            this.name = name;
                     34            this.size = size;
                     35        }
                     36
                     37        public String getName() { return name; }
                     38        public int getSize() { return size; }
                     39    }
                     40
                     41    // VLSM结果类
                     42    public static class VLSMResult {
                     43        private List<SubnetInfo> subnets;
                     44        private SummaryInfo summary;
                     45        private String details;
                     46
                     47        public VLSMResult(List<SubnetInfo> subnets, SummaryInfo summary, String details) {
                     48            this.subnets = subnets;
                     49            this.summary = summary;
                     50            this.details = details;
                     51        }
                     52
                     53        public List<SubnetInfo> getSubnets() { return subnets; }
                     54        public SummaryInfo getSummary() { return summary; }
                     55        public String getDetails() { return details; }
                     56    }
                     57
                     58    // 子网信息类
                     59    public static class SubnetInfo {
                     60        private String name;
                     61        private String networkAddress;
                     62        private String subnetMask;
                     63        private int cidr;
                     64        private String firstHost;
                     65        private String lastHost;
                     66        private String broadcastAddress;
                     67        private int usableHosts;
                     68        private int requiredHosts;
                     69
                     70        public SubnetInfo(String name, String networkAddress, String subnetMask, int cidr,
                     71                         String firstHost, String lastHost, String broadcastAddress,
                     72                         int usableHosts, int requiredHosts) {
                     73            this.name = name;
                     74            this.networkAddress = networkAddress;
                     75            this.subnetMask = subnetMask;
                     76            this.cidr = cidr;
                     77            this.firstHost = firstHost;
                     78            this.lastHost = lastHost;
                     79            this.broadcastAddress = broadcastAddress;
                     80            this.usableHosts = usableHosts;
                     81            this.requiredHosts = requiredHosts;
                     82        }
                     83
                     84        // Getters
                     85        public String getName() { return name; }
                     86        public String getNetworkAddress() { return networkAddress; }
                     87        public String getSubnetMask() { return subnetMask; }
                     88        public int getCidr() { return cidr; }
                     89        public String getFirstHost() { return firstHost; }
                     90        public String getLastHost() { return lastHost; }
                     91        public String getBroadcastAddress() { return broadcastAddress; }
                     92        public int getUsableHosts() { return usableHosts; }
                     93        public int getRequiredHosts() { return requiredHosts; }
                     94    }
                     95
                     96    // 汇总信息类
                     97    public static class SummaryInfo {
                     98        private String originalNetwork;
                     99        private int totalSubnets;
                    100        private int totalHosts;
                    101        private double utilization;
                    102
                    103        public SummaryInfo(String originalNetwork, int totalSubnets, int totalHosts, double utilization) {
                    104            this.originalNetwork = originalNetwork;
                    105            this.totalSubnets = totalSubnets;
                    106            this.totalHosts = totalHosts;
                    107            this.utilization = utilization;
                    108        }
                    109
                    110        // Getters
                    111        public String getOriginalNetwork() { return originalNetwork; }
                    112        public int getTotalSubnets() { return totalSubnets; }
                    113        public int getTotalHosts() { return totalHosts; }
                    114        public double getUtilization() { return utilization; }
                    115    }
                    116
                    117    // 合并结果类
                    118    public static class MergeResult {
                    119        private List<MergedSubnet> mergedSubnets;
                    120        private MergeSummary summary;
                    121        private String details;
                    122
                    123        public MergeResult(List<MergedSubnet> mergedSubnets, MergeSummary summary, String details) {
                    124            this.mergedSubnets = mergedSubnets;
                    125            this.summary = summary;
                    126            this.details = details;
                    127        }
                    128
                    129        public List<MergedSubnet> getMergedSubnets() { return mergedSubnets; }
                    130        public MergeSummary getSummary() { return summary; }
                    131        public String getDetails() { return details; }
                    132    }
                    133
                    134    // 合并后的子网类
                    135    public static class MergedSubnet {
                    136        private String network;
                    137        private List<String> originalSubnets;
                    138        private int hostCount;
                    139
                    140        public MergedSubnet(String network, List<String> originalSubnets, int hostCount) {
                    141            this.network = network;
                    142            this.originalSubnets = originalSubnets;
                    143            this.hostCount = hostCount;
                    144        }
                    145
                    146        // Getters
                    147        public String getNetwork() { return network; }
                    148        public List<String> getOriginalSubnets() { return originalSubnets; }
                    149        public int getHostCount() { return hostCount; }
                    150    }
                    151
                    152    // 合并汇总信息类
                    153    public static class MergeSummary {
                    154        private int originalCount;
                    155        private int mergedCount;
                    156        private int reduction;
                    157        private int totalHosts;
                    158        private double utilization;
                    159
                    160        public MergeSummary(int originalCount, int mergedCount, int reduction, int totalHosts, double utilization) {
                    161            this.originalCount = originalCount;
                    162            this.mergedCount = mergedCount;
                    163            this.reduction = reduction;
                    164            this.totalHosts = totalHosts;
                    165            this.utilization = utilization;
                    166        }
                    167
                    168        // Getters
                    169        public int getOriginalCount() { return originalCount; }
                    170        public int getMergedCount() { return mergedCount; }
                    171        public int getReduction() { return reduction; }
                    172        public int getTotalHosts() { return totalHosts; }
                    173        public double getUtilization() { return utilization; }
                    174    }
                    175
                    176    // 超网结果类
                    177    public static class SupernetResult {
                    178        private String networkAddress;
                    179        private String subnetMask;
                    180        private int cidr;
                    181        private String broadcastAddress;
                    182        private String firstHost;
                    183        private String lastHost;
                    184        private int totalHosts;
                    185        private String startIP;
                    186        private String endIP;
                    187        private String details;
                    188
                    189        public SupernetResult(String networkAddress, String subnetMask, int cidr,
                    190                            String broadcastAddress, String firstHost, String lastHost,
                    191                            int totalHosts, String startIP, String endIP, String details) {
                    192            this.networkAddress = networkAddress;
                    193            this.subnetMask = subnetMask;
                    194            this.cidr = cidr;
                    195            this.broadcastAddress = broadcastAddress;
                    196            this.firstHost = firstHost;
                    197            this.lastHost = lastHost;
                    198            this.totalHosts = totalHosts;
                    199            this.startIP = startIP;
                    200            this.endIP = endIP;
                    201            this.details = details;
                    202        }
                    203
                    204        // Getters
                    205        public String getNetworkAddress() { return networkAddress; }
                    206        public String getSubnetMask() { return subnetMask; }
                    207        public int getCidr() { return cidr; }
                    208        public String getBroadcastAddress() { return broadcastAddress; }
                    209        public String getFirstHost() { return firstHost; }
                    210        public String getLastHost() { return lastHost; }
                    211        public int getTotalHosts() { return totalHosts; }
                    212        public String getStartIP() { return startIP; }
                    213        public String getEndIP() { return endIP; }
                    214        public String getDetails() { return details; }
                    215    }
                    216
                    217    // 规划结果类
                    218    public static class PlanningResult {
                    219        private List<DepartmentInfo> departments;
                    220        private PlanningSummary summary;
                    221        private String details;
                    222
                    223        public PlanningResult(List<DepartmentInfo> departments, PlanningSummary summary, String details) {
                    224            this.departments = departments;
                    225            this.summary = summary;
                    226            this.details = details;
                    227        }
                    228
                    229        public List<DepartmentInfo> getDepartments() { return departments; }
                    230        public PlanningSummary getSummary() { return summary; }
                    231        public String getDetails() { return details; }
                    232    }
                    233
                    234    // 部门信息类
                    235    public static class DepartmentInfo {
                    236        private String name;
                    237        private String networkAddress;
                    238        private String subnetMask;
                    239        private int cidr;
                    240        private String firstHost;
                    241        private String lastHost;
                    242        private int allocatedHosts;
                    243        private int totalHosts;
                    244
                    245        public DepartmentInfo(String name, String networkAddress, String subnetMask, int cidr,
                    246                            String firstHost, String lastHost, int allocatedHosts, int totalHosts) {
                    247            this.name = name;
                    248            this.networkAddress = networkAddress;
                    249            this.subnetMask = subnetMask;
                    250            this.cidr = cidr;
                    251            this.firstHost = firstHost;
                    252            this.lastHost = lastHost;
                    253            this.allocatedHosts = allocatedHosts;
                    254            this.totalHosts = totalHosts;
                    255        }
                    256
                    257        // Getters
                    258        public String getName() { return name; }
                    259        public String getNetworkAddress() { return networkAddress; }
                    260        public String getSubnetMask() { return subnetMask; }
                    261        public int getCidr() { return cidr; }
                    262        public String getFirstHost() { return firstHost; }
                    263        public String getLastHost() { return lastHost; }
                    264        public int getAllocatedHosts() { return allocatedHosts; }
                    265        public int getTotalHosts() { return totalHosts; }
                    266    }
                    267
                    268    // 规划汇总信息类
                    269    public static class PlanningSummary {
                    270        private int totalSpace;
                    271        private int allocatedSpace;
                    272        private int remainingSpace;
                    273        private double utilization;
                    274        private int departmentCount;
                    275
                    276        public PlanningSummary(int totalSpace, int allocatedSpace, int remainingSpace,
                    277                             double utilization, int departmentCount) {
                    278            this.totalSpace = totalSpace;
                    279            this.allocatedSpace = allocatedSpace;
                    280            this.remainingSpace = remainingSpace;
                    281            this.utilization = utilization;
                    282            this.departmentCount = departmentCount;
                    283        }
                    284
                    285        // Getters
                    286        public int getTotalSpace() { return totalSpace; }
                    287        public int getAllocatedSpace() { return allocatedSpace; }
                    288        public int getRemainingSpace() { return remainingSpace; }
                    289        public double getUtilization() { return utilization; }
                    290        public int getDepartmentCount() { return departmentCount; }
                    291    }
                    292
                    293    /**
                    294     * 验证IP地址格式
                    295     */
                    296    public boolean validateIP(String ip) {
                    297        return IP_PATTERN.matcher(ip).matches();
                    298    }
                    299
                    300    /**
                    301     * 验证CIDR格式
                    302     */
                    303    public boolean validateCIDR(String cidr) {
                    304        return CIDR_PATTERN.matcher(cidr).matches();
                    305    }
                    306
                    307    /**
                    308     * IP地址转换为长整数
                    309     */
                    310    public long ipToLong(String ip) throws IllegalArgumentException {
                    311        if (!validateIP(ip)) {
                    312            throw new IllegalArgumentException("无效的IP地址格式");
                    313        }
                    314
                    315        String[] parts = ip.split("\\.");
                    316        long result = 0;
                    317        for (int i = 0; i < 4; i++) {
                    318            result = result << 8 | Integer.parseInt(parts[i]);
                    319        }
                    320        return result;
                    321    }
                    322
                    323    /**
                    324     * 长整数转换为IP地址
                    325     */
                    326    public String longToIP(long ipLong) {
                    327        return String.format("%d.%d.%d.%d",
                    328                (ipLong >> 24) & 0xFF,
                    329                (ipLong >> 16) & 0xFF,
                    330                (ipLong >> 8) & 0xFF,
                    331                ipLong & 0xFF);
                    332    }
                    333
                    334    /**
                    335     * 获取子网掩码
                    336     */
                    337    public String getSubnetMask(int cidr) {
                    338        long mask = (0xFFFFFFFFL << (32 - cidr)) & 0xFFFFFFFFL;
                    339        return longToIP(mask);
                    340    }
                    341
                    342    /**
                    343     * 获取网络地址
                    344     */
                    345    public String getNetworkAddress(String ip, int cidr) throws IllegalArgumentException {
                    346        long ipLong = ipToLong(ip);
                    347        long mask = (0xFFFFFFFFL << (32 - cidr)) & 0xFFFFFFFFL;
                    348        long networkLong = ipLong & mask;
                    349        return longToIP(networkLong);
                    350    }
                    351
                    352    /**
                    353     * 获取广播地址
                    354     */
                    355    public String getBroadcastAddress(String ip, int cidr) throws IllegalArgumentException {
                    356        long ipLong = ipToLong(ip);
                    357        long mask = (0xFFFFFFFFL << (32 - cidr)) & 0xFFFFFFFFL;
                    358        long broadcastLong = ipLong | (~mask & 0xFFFFFFFFL);
                    359        return longToIP(broadcastLong);
                    360    }
                    361
                    362    /**
                    363     * 获取第一个可用主机地址
                    364     */
                    365    public String getFirstHost(String ip, int cidr) throws IllegalArgumentException {
                    366        String networkIP = getNetworkAddress(ip, cidr);
                    367        long networkLong = ipToLong(networkIP);
                    368        return longToIP(networkLong + 1);
                    369    }
                    370
                    371    /**
                    372     * 获取最后一个可用主机地址
                    373     */
                    374    public String getLastHost(String ip, int cidr) throws IllegalArgumentException {
                    375        String broadcastIP = getBroadcastAddress(ip, cidr);
                    376        long broadcastLong = ipToLong(broadcastIP);
                    377        return longToIP(broadcastLong - 1);
                    378    }
                    379
                    380    /**
                    381     * 计算可用主机数量
                    382     */
                    383    public int getUsableHosts(int cidr) {
                    384        return (int) (Math.pow(2, 32 - cidr) - 2);
                    385    }
                    386
                    387    /**
                    388     * 解析CIDR格式
                    389     */
                    390    public String[] parseCIDR(String cidr) throws IllegalArgumentException {
                    391        if (!validateCIDR(cidr)) {
                    392            throw new IllegalArgumentException("无效的CIDR格式");
                    393        }
                    394
                    395        String[] parts = cidr.split("/");
                    396        return new String[]{parts[0], parts[1]};
                    397    }
                    398
                    399    /**
                    400     * VLSM子网划分
                    401     */
                    402    public VLSMResult calculateVLSM(String networkCIDR, List<SubnetRequirement> subnetRequirements,
                    403                                  Map<String, Object> options) throws IllegalArgumentException {
                    404        String[] parsed = parseCIDR(networkCIDR);
                    405        String networkIP = parsed[0];
                    406        int networkCIDRBits = Integer.parseInt(parsed[1]);
                    407
                    408        String networkAddress = getNetworkAddress(networkIP, networkCIDRBits);
                    409        long networkLong = ipToLong(networkAddress);
                    410        int totalHosts = getUsableHosts(networkCIDRBits);
                    411
                    412        // 按主机数量排序（如果需要）
                    413        List<SubnetRequirement> sortedRequirements = new ArrayList<>(subnetRequirements);
                    414        if (options != null && options.containsKey("optimize_order") && 
                    415            (Boolean) options.get("optimize_order")) {
                    416            sortedRequirements.sort((a, b) -> Integer.compare(b.getHosts(), a.getHosts()));
                    417        }
                    418
                    419        // 计算每个子网需要的掩码位数
                    420        List<SubnetInfo> subnets = new ArrayList<>();
                    421        long currentNetworkLong = networkLong;
                    422
                    423        for (SubnetRequirement requirement : sortedRequirements) {
                    424            int requiredHosts = requirement.getHosts();
                    425            if (options != null && options.containsKey("include_network_broadcast") && 
                    426                (Boolean) options.get("include_network_broadcast")) {
                    427                requiredHosts += 2;
                    428            }
                    429
                    430            int requiredCIDR = 32 - (int) Math.ceil(Math.log(requiredHosts) / Math.log(2));
                    431
                    432            if (requiredCIDR < networkCIDRBits) {
                    433                throw new IllegalArgumentException("子网 " + requirement.getName() + " 需要的主机数超出可用空间");
                    434            }
                    435
                    436            String subnetNetworkIP = longToIP(currentNetworkLong);
                    437            String subnetMask = getSubnetMask(requiredCIDR);
                    438            int subnetHosts = getUsableHosts(requiredCIDR);
                    439
                    440            String firstHost = getFirstHost(subnetNetworkIP, requiredCIDR);
                    441            String lastHost = getLastHost(subnetNetworkIP, requiredCIDR);
                    442            String broadcastAddress = getBroadcastAddress(subnetNetworkIP, requiredCIDR);
                    443
                    444            subnets.add(new SubnetInfo(
                    445                    requirement.getName(),
                    446                    subnetNetworkIP,
                    447                    subnetMask,
                    448                    requiredCIDR,
                    449                    firstHost,
                    450                    lastHost,
                    451                    broadcastAddress,
                    452                    subnetHosts,
                    453                    requirement.getHosts()
                    454            ));
                    455
                    456            // 计算下一个子网的起始地址
                    457            long subnetSize = (long) Math.pow(2, 32 - requiredCIDR);
                    458            currentNetworkLong += subnetSize;
                    459        }
                    460
                    461        // 计算汇总信息
                    462        int totalRequiredHosts = sortedRequirements.stream().mapToInt(SubnetRequirement::getHosts).sum();
                    463        double utilization = (double) totalRequiredHosts / totalHosts * 100;
                    464
                    465        return new VLSMResult(
                    466                subnets,
                    467                new SummaryInfo(networkCIDR, subnets.size(), totalRequiredHosts, utilization),
                    468                String.format("VLSM划分完成，共创建 %d 个子网，地址利用率 %.2f%%", subnets.size(), utilization)
                    469        );
                    470    }
                    471
                    472    /**
                    473     * 子网合并
                    474     */
                    475    public MergeResult mergeSubnets(List<String> subnetList, Map<String, Object> options) 
                    476            throws IllegalArgumentException {
                    477        List<SubnetData> subnets = new ArrayList<>();
                    478
                    479        // 解析子网列表
                    480        for (String subnetStr : subnetList) {
                    481            if (!validateCIDR(subnetStr)) {
                    482                if (options != null && options.containsKey("validate_subnets") && 
                    483                    (Boolean) options.get("validate_subnets")) {
                    484                    throw new IllegalArgumentException("无效的子网格式: " + subnetStr);
                    485                }
                    486                continue;
                    487            }
                    488
                    489            String[] parsed = parseCIDR(subnetStr);
                    490            String ip = parsed[0];
                    491            int cidr = Integer.parseInt(parsed[1]);
                    492
                    493            String networkIP = getNetworkAddress(ip, cidr);
                    494            long networkLong = ipToLong(networkIP);
                    495
                    496            subnets.add(new SubnetData(subnetStr, networkIP, cidr, networkLong, getUsableHosts(cidr)));
                    497        }
                    498
                    499        if (subnets.isEmpty()) {
                    500            throw new IllegalArgumentException("没有有效的子网可以合并");
                    501        }
                    502
                    503        // 按网络地址排序
                    504        subnets.sort(Comparator.comparingLong(SubnetData::getNetworkLong));
                    505
                    506        List<MergedSubnet> mergedSubnets = new ArrayList<>();
                    507        List<SubnetData> currentGroup = new ArrayList<>();
                    508        currentGroup.add(subnets.get(0));
                    509
                    510        for (int i = 1; i < subnets.size(); i++) {
                    511            SubnetData current = subnets.get(i);
                    512            SubnetData last = currentGroup.get(currentGroup.size() - 1);
                    513
                    514            // 检查是否相邻或连续
                    515            boolean isAdjacent = false;
                    516            boolean isContiguous = false;
                    517
                    518            if (options != null && options.containsKey("merge_adjacent") && 
                    519                (Boolean) options.get("merge_adjacent")) {
                    520                isAdjacent = areSubnetsAdjacent(last, current);
                    521            }
                    522
                    523            if (options != null && options.containsKey("merge_contiguous") && 
                    524                (Boolean) options.get("merge_contiguous")) {
                    525                isContiguous = areSubnetsContiguous(last, current);
                    526            }
                    527
                    528            if (isAdjacent || isContiguous) {
                    529                currentGroup.add(current);
                    530            } else {
                    531                // 合并当前组
                    532                if (currentGroup.size() > 1) {
                    533                    mergedSubnets.add(mergeSubnetGroup(currentGroup));
                    534                } else {
                    535                    List<String> originalSubnets = new ArrayList<>();
                    536                    originalSubnets.add(currentGroup.get(0).getNetwork());
                    537                    mergedSubnets.add(new MergedSubnet(
                    538                            currentGroup.get(0).getNetwork(),
                    539                            originalSubnets,
                    540                            currentGroup.get(0).getHostCount()
                    541                    ));
                    542                }
                    543                currentGroup = new ArrayList<>();
                    544                currentGroup.add(current);
                    545            }
                    546        }
                    547
                    548        // 处理最后一组
                    549        if (currentGroup.size() > 1) {
                    550            mergedSubnets.add(mergeSubnetGroup(currentGroup));
                    551        } else {
                    552            List<String> originalSubnets = new ArrayList<>();
                    553            originalSubnets.add(currentGroup.get(0).getNetwork());
                    554            mergedSubnets.add(new MergedSubnet(
                    555                    currentGroup.get(0).getNetwork(),
                    556                    originalSubnets,
                    557                    currentGroup.get(0).getHostCount()
                    558            ));
                    559        }
                    560
                    561        // 计算汇总信息
                    562        int originalCount = subnets.size();
                    563        int mergedCount = mergedSubnets.size();
                    564        int reduction = originalCount - mergedCount;
                    565        int totalHosts = mergedSubnets.stream().mapToInt(MergedSubnet::getHostCount).sum();
                    566
                    567        return new MergeResult(
                    568                mergedSubnets,
                    569                new MergeSummary(originalCount, mergedCount, reduction, totalHosts, 
                    570                               (double) totalHosts / 0xFFFFFFFFL * 100),
                    571                String.format("合并完成，从 %d 个子网合并为 %d 个，减少 %d 个", originalCount, mergedCount, reduction)
                    572        );
                    573    }
                    574
                    575    // 子网数据内部类
                    576    private static class SubnetData {
                    577        private String network;
                    578        private String networkIP;
                    579        private int cidr;
                    580        private long networkLong;
                    581        private int hostCount;
                    582
                    583        public SubnetData(String network, String networkIP, int cidr, long networkLong, int hostCount) {
                    584            this.network = network;
                    585            this.networkIP = networkIP;
                    586            this.cidr = cidr;
                    587            this.networkLong = networkLong;
                    588            this.hostCount = hostCount;
                    589        }
                    590
                    591        public String getNetwork() { return network; }
                    592        public String getNetworkIP() { return networkIP; }
                    593        public int getCidr() { return cidr; }
                    594        public long getNetworkLong() { return networkLong; }
                    595        public int getHostCount() { return hostCount; }
                    596    }
                    597
                    598    /**
                    599     * 检查两个子网是否相邻
                    600     */
                    601    private boolean areSubnetsAdjacent(SubnetData subnet1, SubnetData subnet2) {
                    602        String broadcast1 = getBroadcastAddress(subnet1.getNetworkIP(), subnet1.getCidr());
                    603        long broadcast1Long = ipToLong(broadcast1);
                    604        return subnet2.getNetworkLong() == broadcast1Long + 1;
                    605    }
                    606
                    607    /**
                    608     * 检查两个子网是否连续
                    609     */
                    610    private boolean areSubnetsContiguous(SubnetData subnet1, SubnetData subnet2) {
                    611        String broadcast1 = getBroadcastAddress(subnet1.getNetworkIP(), subnet1.getCidr());
                    612        long broadcast1Long = ipToLong(broadcast1);
                    613        return subnet2.getNetworkLong() <= broadcast1Long + 1;
                    614    }
                    615
                    616    /**
                    617     * 合并子网组
                    618     */
                    619    private MergedSubnet mergeSubnetGroup(List<SubnetData> subnetGroup) {
                    620        SubnetData first = subnetGroup.get(0);
                    621        SubnetData last = subnetGroup.get(subnetGroup.size() - 1);
                    622        String lastBroadcast = getBroadcastAddress(last.getNetworkIP(), last.getCidr());
                    623        long lastBroadcastLong = ipToLong(lastBroadcast);
                    624
                    625        // 计算合并后的CIDR
                    626        long rangeSize = lastBroadcastLong - first.getNetworkLong() + 1;
                    627        int mergedCIDR = 32 - (int) Math.ceil(Math.log(rangeSize) / Math.log(2));
                    628
                    629        String mergedNetworkIP = longToIP(first.getNetworkLong());
                    630        String mergedNetwork = mergedNetworkIP + "/" + mergedCIDR;
                    631        int mergedHostCount = getUsableHosts(mergedCIDR);
                    632
                    633        List<String> originalSubnets = new ArrayList<>();
                    634        for (SubnetData subnet : subnetGroup) {
                    635            originalSubnets.add(subnet.getNetwork());
                    636        }
                    637
                    638        return new MergedSubnet(mergedNetwork, originalSubnets, mergedHostCount);
                    639    }
                    640
                    641    /**
                    642     * 超网计算
                    643     */
                    644    public SupernetResult calculateSupernet(String startIP, String endIP, Map<String, Object> options) 
                    645            throws IllegalArgumentException {
                    646        if (!validateIP(startIP) || !validateIP(endIP)) {
                    647            throw new IllegalArgumentException("无效的IP地址格式");
                    648        }
                    649
                    650        long startLong = ipToLong(startIP);
                    651        long endLong = ipToLong(endIP);
                    652
                    653        if (startLong > endLong) {
                    654            throw new IllegalArgumentException("起始IP不能大于结束IP");
                    655        }
                    656
                    657        // 计算包含该范围的最小超网
                    658        long rangeSize = endLong - startLong + 1;
                    659        int requiredCIDR = 32 - (int) Math.ceil(Math.log(rangeSize) / Math.log(2));
                    660
                    661        // 找到包含该范围的最小网络地址
                    662        long mask = (0xFFFFFFFFL << (32 - requiredCIDR)) & 0xFFFFFFFFL;
                    663        long networkLong = startLong & mask;
                    664        String networkIP = longToIP(networkLong);
                    665
                    666        // 验证该网络是否包含整个范围
                    667        long broadcastLong = networkLong | (~mask & 0xFFFFFFFFL);
                    668        if (broadcastLong < endLong) {
                    669            // 需要更大的网络
                    670            int newCIDR = requiredCIDR - 1;
                    671            long newMask = (0xFFFFFFFFL << (32 - newCIDR)) & 0xFFFFFFFFL;
                    672            long newNetworkLong = startLong & newMask;
                    673            String newNetworkIP = longToIP(newNetworkLong);
                    674
                    675            return new SupernetResult(
                    676                    newNetworkIP,
                    677                    getSubnetMask(newCIDR),
                    678                    newCIDR,
                    679                    longToIP(newNetworkLong | (~newMask & 0xFFFFFFFFL)),
                    680                    longToIP(newNetworkLong + 1),
                    681                    longToIP((newNetworkLong | (~newMask & 0xFFFFFFFFL)) - 1),
                    682                    getUsableHosts(newCIDR),
                    683                    startIP,
                    684                    endIP,
                    685                    String.format("计算得到包含范围 %s-%s 的最小超网 %s/%d", startIP, endIP, newNetworkIP, newCIDR)
                    686            );
                    687        }
                    688
                    689        return new SupernetResult(
                    690                networkIP,
                    691                getSubnetMask(requiredCIDR),
                    692                requiredCIDR,
                    693                longToIP(broadcastLong),
                    694                longToIP(networkLong + 1),
                    695                longToIP(broadcastLong - 1),
                    696                getUsableHosts(requiredCIDR),
                    697                startIP,
                    698                endIP,
                    699                String.format("计算得到包含范围 %s-%s 的最小超网 %s/%d", startIP, endIP, networkIP, requiredCIDR)
                    700        );
                    701    }
                    702
                    703    /**
                    704     * 网络规划
                    705     */
                    706    public PlanningResult generateNetworkPlan(String addressSpace, List<DepartmentRequirement> departmentRequirements,
                    707                                            Map<String, Object> options) throws IllegalArgumentException {
                    708        String[] parsed = parseCIDR(addressSpace);
                    709        String networkIP = parsed[0];
                    710        int networkCIDRBits = Integer.parseInt(parsed[1]);
                    711
                    712        String networkAddress = getNetworkAddress(networkIP, networkCIDRBits);
                    713        long networkLong = ipToLong(networkAddress);
                    714        int totalSpace = getUsableHosts(networkCIDRBits);
                    715
                    716        // 按部门大小排序
                    717        List<DepartmentRequirement> sortedDepartments = new ArrayList<>(departmentRequirements);
                    718        if (options != null && options.containsKey("optimize_utilization") && 
                    719            (Boolean) options.get("optimize_utilization")) {
                    720            sortedDepartments.sort((a, b) -> Integer.compare(b.getSize(), a.getSize()));
                    721        }
                    722
                    723        List<DepartmentInfo> departments = new ArrayList<>();
                    724        long currentNetworkLong = networkLong;
                    725        int allocatedSpace = 0;
                    726
                    727        for (DepartmentRequirement dept : sortedDepartments) {
                    728            int requiredHosts = dept.getSize();
                    729            if (options != null && options.containsKey("reserve_space") && 
                    730                (Boolean) options.get("reserve_space")) {
                    731                requiredHosts += (int) Math.ceil(dept.getSize() * 0.2);
                    732            }
                    733
                    734            int requiredCIDR = 32 - (int) Math.ceil(Math.log(requiredHosts + 2) / Math.log(2)); // +2 for network and broadcast
                    735
                    736            if (requiredCIDR < networkCIDRBits) {
                    737                throw new IllegalArgumentException("部门 " + dept.getName() + " 需要的主机数超出可用空间");
                    738            }
                    739
                    740            String deptNetworkIP = longToIP(currentNetworkLong);
                    741            String deptSubnetMask = getSubnetMask(requiredCIDR);
                    742            int deptHosts = getUsableHosts(requiredCIDR);
                    743
                    744            String firstHost = getFirstHost(deptNetworkIP, requiredCIDR);
                    745            String lastHost = getLastHost(deptNetworkIP, requiredCIDR);
                    746
                    747            departments.add(new DepartmentInfo(
                    748                    dept.getName(),
                    749                    deptNetworkIP,
                    750                    deptSubnetMask,
                    751                    requiredCIDR,
                    752                    firstHost,
                    753                    lastHost,
                    754                    dept.getSize(),
                    755                    deptHosts
                    756            ));
                    757
                    758            allocatedSpace += deptHosts;
                    759            long subnetSize = (long) Math.pow(2, 32 - requiredCIDR);
                    760            currentNetworkLong += subnetSize;
                    761        }
                    762
                    763        int remainingSpace = totalSpace - allocatedSpace;
                    764        double utilization = (double) allocatedSpace / totalSpace * 100;
                    765
                    766        return new PlanningResult(
                    767                departments,
                    768                new PlanningSummary(totalSpace, allocatedSpace, remainingSpace, utilization, departments.size()),
                    769                String.format("网络规划完成，共分配 %d 个部门，地址利用率 %.2f%%，剩余空间 %d 个主机", 
                    770                            departments.size(), utilization, remainingSpace)
                    771        );
                    772    }
                    773
                    774    public static void main(String[] args) {
                    775        SubnetCalculator calculator = new SubnetCalculator();
                    776
                    777        System.out.println("=== 子网划分工具 - Java版本 ===");
                    778
                    779        // VLSM示例
                    780        System.out.println("\n--- VLSM子网划分示例 ---");
                    781        try {
                    782            List<SubnetRequirement> requirements = Arrays.asList(
                    783                    new SubnetRequirement("销售部", 50),
                    784                    new SubnetRequirement("技术部", 30),
                    785                    new SubnetRequirement("财务部", 10),
                    786                    new SubnetRequirement("人事部", 5)
                    787            );
                    788
                    789            Map<String, Object> options = new HashMap<>();
                    790            options.put("optimize_order", true);
                    791            options.put("include_network_broadcast", true);
                    792
                    793            VLSMResult vlsmResult = calculator.calculateVLSM("192.168.1.0/24", requirements, options);
                    794            System.out.println("VLSM结果:");
                    795            for (SubnetInfo subnet : vlsmResult.getSubnets()) {
                    796                System.out.printf("  %s: %s/%d (%s - %s)%n", 
                    797                                subnet.getName(), subnet.getNetworkAddress(), subnet.getCidr(),
                    798                                subnet.getFirstHost(), subnet.getLastHost());
                    799            }
                    800            System.out.printf("汇总: 原始网络=%s, 总子网数=%d, 总主机数=%d, 利用率=%.2f%%%n",
                    801                            vlsmResult.getSummary().getOriginalNetwork(),
                    802                            vlsmResult.getSummary().getTotalSubnets(),
                    803                            vlsmResult.getSummary().getTotalHosts(),
                    804                            vlsmResult.getSummary().getUtilization());
                    805        } catch (Exception e) {
                    806            System.err.println("VLSM错误: " + e.getMessage());
                    807        }
                    808
                    809        // 子网合并示例
                    810        System.out.println("\n--- 子网合并示例 ---");
                    811        try {
                    812            List<String> subnetList = Arrays.asList(
                    813                    "192.168.1.0/26",
                    814                    "192.168.1.64/26",
                    815                    "192.168.1.128/26",
                    816                    "192.168.1.192/26"
                    817            );
                    818
                    819            Map<String, Object> options = new HashMap<>();
                    820            options.put("merge_adjacent", true);
                    821            options.put("merge_contiguous", true);
                    822            options.put("validate_subnets", true);
                    823
                    824            MergeResult mergeResult = calculator.mergeSubnets(subnetList, options);
                    825            System.out.println("合并结果:");
                    826            for (MergedSubnet merged : mergeResult.getMergedSubnets()) {
                    827                System.out.printf("  %s (包含: %s)%n", merged.getNetwork(), 
                    828                                String.join(", ", merged.getOriginalSubnets()));
                    829            }
                    830            System.out.printf("汇总: 原子网数=%d, 合并后=%d, 减少=%d, 利用率=%.4f%%%n",
                    831                            mergeResult.getSummary().getOriginalCount(),
                    832                            mergeResult.getSummary().getMergedCount(),
                    833                            mergeResult.getSummary().getReduction(),
                    834                            mergeResult.getSummary().getUtilization());
                    835        } catch (Exception e) {
                    836            System.err.println("合并错误: " + e.getMessage());
                    837        }
                    838
                    839        // 超网计算示例
                    840        System.out.println("\n--- 超网计算示例 ---");
                    841        try {
                    842            SupernetResult supernetResult = calculator.calculateSupernet("192.168.1.10", "192.168.1.50", null);
                    843            System.out.printf("超网结果: %s/%d%n", supernetResult.getNetworkAddress(), supernetResult.getCidr());
                    844            System.out.printf("详细信息: %s%n", supernetResult.getDetails());
                    845        } catch (Exception e) {
                    846            System.err.println("超网错误: " + e.getMessage());
                    847        }
                    848
                    849        // 网络规划示例
                    850        System.out.println("\n--- 网络规划示例 ---");
                    851        try {
                    852            List<DepartmentRequirement> deptRequirements = Arrays.asList(
                    853                    new DepartmentRequirement("总部", 200),
                    854                    new DepartmentRequirement("分公司A", 100),
                    855                    new DepartmentRequirement("分公司B", 80),
                    856                    new DepartmentRequirement("研发中心", 150)
                    857            );
                    858
                    859            Map<String, Object> options = new HashMap<>();
                    860            options.put("optimize_utilization", true);
                    861            options.put("reserve_space", true);
                    862
                    863            PlanningResult planningResult = calculator.generateNetworkPlan("10.0.0.0/8", deptRequirements, options);
                    864            System.out.println("规划结果:");
                    865            for (DepartmentInfo dept : planningResult.getDepartments()) {
                    866                System.out.printf("  %s: %s/%d (%d 主机)%n", dept.getName(), 
                    867                                dept.getNetworkAddress(), dept.getCidr(), dept.getAllocatedHosts());
                    868            }
                    869            System.out.printf("汇总: 总空间=%d, 已分配=%d, 剩余=%d, 利用率=%.2f%%, 部门数=%d%n",
                    870                            planningResult.getSummary().getTotalSpace(),
                    871                            planningResult.getSummary().getAllocatedSpace(),
                    872                            planningResult.getSummary().getRemainingSpace(),
                    873                            planningResult.getSummary().getUtilization(),
                    874                            planningResult.getSummary().getDepartmentCount());
                    875        } catch (Exception e) {
                    876            System.err.println("规划错误: " + e.getMessage());
                    877        }
                    878    }
                    879}