用Java程序语言写出平均分配IP地址的子网划分的代码。

由于IP地址的分配是根据子网掩码来进行的，因此我们需要先定义一个类 SubnetMask 来表示子网掩码：

public class SubnetMask {
    private int[] mask;

    public SubnetMask(int[] mask) {
        this.mask = mask;
    }

    public int[] getMask() {
        return mask;
    }

    public int getSubnetBits() {
        int count = 0;
        for (int i = 0; i < mask.length; i++) {
            int b = mask[i];
            if (b == 255) {
                count += 8;
            } else if (b == 0) {
                count += 0;
            } else {
                while (b > 0) {
                    count++;
                    b = (b << 1) & 0xff;
                }
            }
        }
        return count;
    }

    public int getHostBits() {
        return 32 - getSubnetBits();
    }

    public int getSubnetCount() {
        return (int) Math.pow(2, getHostBits());
    }

    public int getHostCount() {
        return (int) Math.pow(2, getHostBits()) - 2;
    }
}

这个类包含了一些常用的子网掩码计算方法，如获取子网掩码、获取子网位数、获取主机位数、获取子网数和获取主机数。

接下来，我们定义一个类 Subnet 来表示一个子网：

public class Subnet {
    private int[] network;
    private int[] broadcast;
    private int[] firstHost;
    private int[] lastHost;
    private int hostCount;

    public Subnet(int[] network, int[] broadcast, int[] firstHost, int[] lastHost, int hostCount) {
        this.network = network;
        this.broadcast = broadcast;
        this.firstHost = firstHost;
        this.lastHost = lastHost;
        this.hostCount = hostCount;
    }

    public int[] getNetwork() {
        return network;
    }

    public int[] getBroadcast() {
        return broadcast;
    }

    public int[] getFirstHost() {
        return firstHost;
    }

    public int[] getLastHost() {
        return lastHost;
    }

    public int getHostCount() {
        return hostCount;
    }
}

这个类包含了一个子网的各种信息，如网络地址、广播地址、第一个主机地址、最后一个主机地址和主机数。

现在我们可以写出平均分配IP地址的子网划分的代码了：

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

public class SubnetAllocation {
    private int[] baseIp;
    private SubnetMask subnetMask;
    private int subnetCount;

    public SubnetAllocation(int[] baseIp, SubnetMask subnetMask, int subnetCount) {
        this.baseIp = baseIp;
        this.subnetMask = subnetMask;
        this.subnetCount = subnetCount;
    }

    public List<Subnet> allocate() {
        int subnetBits = subnetMask.getSubnetBits();
        int hostBits = subnetMask.getHostBits();
        int[] subnetMaskArray = subnetMask.getMask();
        int[] network = new int[4];
        int[] broadcast = new int[4];
        int[] firstHost = new int[4];
        int[] lastHost = new int[4];
        int hostCount = subnetMask.getHostCount();
        int step = (int) Math.pow(2, hostBits);
        List<Subnet> subnets = new ArrayList<>();
        for (int i = 0; i < subnetCount; i++) {
            int subnetNumber = i + 1;
            network[0] = baseIp[0] & subnetMaskArray[0];
            network[1] = baseIp[1] & subnetMaskArray[1];
            network[2] = baseIp[2] & subnetMaskArray[2];
            network[3] = (baseIp[3] & subnetMaskArray[3]) + (i * step);
            broadcast[0] = network[0] | (~subnetMaskArray[0] & 0xff);
            broadcast[1] = network[1] | (~subnetMaskArray[1] & 0xff);
            broadcast[2] = network[2] | (~subnetMaskArray[2] & 0xff);
            broadcast[3] = network[3] | (hostCount & 0xff);
            firstHost[0] = network[0];
            firstHost[1] = network[1];
            firstHost[2] = network[2];
            firstHost[3] = (network[3] + 1) & 0xff;
            lastHost[0] = broadcast[0];
            lastHost[1] = broadcast[1];
            lastHost[2] = broadcast[2];
            lastHost[3] = (broadcast[3] - 1) & 0xff;
            subnets.add(new Subnet(network, broadcast, firstHost, lastHost, hostCount));
        }
        return subnets;
    }
}

在这个类中，我们通过 baseIp、subnetMask 和 subnetCount 来定义了一个子网划分。然后，我们用一个 for 循环来遍历所有的子网，对于每个子网，我们计算出它的网络地址、广播地址、第一个主机地址、最后一个主机地址和主机数，并将这些信息保存在 Subnet 对象中，最后将所有的 Subnet 对象保存在一个 List 中返回