如何在JAVA中合并位字符串

我有这个

ArrayList

集群：

[[1,0,0,0]，[0,0,0,0]，[0,0,0,0]，[0,0,1,1]，[1,1,1,0]

对于每个位字符串（内部arrayList），熵的计算和生成如下所示：

inner index #0 : [1, 0, 0, 0] = 0.811
inner index #1 : [0, 0, 0, 0] = 0
inner index #2 : [0, 0, 0, 0] = 0
inner index #3 : [0, 0, 1, 1] = 1
inner index #4 : [1, 1, 1, 0] = 0.811

熵的计算如下：
对于内部索引#0：

0的概率为3/4=0.75，1的概率为1/4=0.25。
然后，熵=-（（0.75）（log（0.75）/log（2））+（0.25）（log（0.25）/log（2））=0.811

然后，在获得所有位的熵之后，我想合并这两个位，如下所示：

假设#0和#1，那么位将变成：

**Before merge**
inner index #0 : [1,0,0,0]  
inner index #1 : [0,0,0,0]  

**After merge**  
inner index #0 and #1 : [ [1,0], [0,0], [0,0], [0,0] ]

然后在合并之后，我将发现存在

[0,0]

、

[0,1]

、

[1,0]

和

[1,0]

（可能的排列）的概率，以再次计算熵。因此，在上述情况下：

P([0,0]) = 3/4 = 0.75 (because there are 3 [0,0] in outer array of 4)  
P([0,1]) = 0/4 = 0  
P([1,0]) = 1/4 = 0.25 (because there are 1 [1,0] in outer array of 4)    
P([1,1]) = 0/4 = 0

然后用同样的方法计算熵

合并#0和#1之后，假设我想将#0和#1与#3合并，这样它将产生如下结果：

**Before merge**  
#0 and #1 : [ [1,0], [0,0], [0,0], [0,0] ]  
#3 : [0, 0, 1, 1]  

**After merge**  
#0, #1, #3 : [ [1,0,0], [0,0,0], [0,0,1], [0,0,1] ]  

然后计算所有可能排列的概率

[0,0,0]

，…，

[1,1,1]

，并重复计算熵

---

因此，我如何用java编写代码，以灵活的方式查找概率，因为位可能更长，而查找概率的排列模式可能更长

这是我尝试过的代码，但它只适用于第一个代码，不确定如何合并它并计算合并时的概率：

public static double calculateEntropy(ArrayList<Integer> bitSet){
     double entropy = 0.0;
     double P_C0,P_C1;
     int C0_count = 0, C1_count = 0;
     int bitSize = bitSet.size();

    System.out.println("bitSet to calculate: " + bitSet);
    System.out.println("bitSize = " + bitSize);

    for (int k = 0 ; k < bitSize; k++){
        if (bitSet.get(k) == 0)
            C0_count++;
        else if (bitSet.get(k) == 1)
            C1_count++;
    }

    System.out.println("CO: " + C0_count);
    System.out.println("C1: " + C1_count);

    P_C0 = (double)C0_count/bitSize;
    P_C1 = (double)C1_count/bitSize;

    System.out.println("P_C0: " + P_C0);
    System.out.println("P_C1: " + P_C1);

    entropy = -( (P_C0*(Math.log(P_C0)/Math.log(2))) + (P_C1*(Math.log(P_C1)/Math.log(2))) );

    if(Double.isNaN(entropy)){
        entropy = (double)0.00;

    }

    return entropy;
}    

公共静态双重计算属性（ArrayList位集）{
双熵=0.0；
双P_C0，P_C1；
int C0_计数=0，C1_计数=0；
int bitSize=bitSet.size（）；
System.out.println（“要计算的位集：“+位集”）；
System.out.println（“bitSize=“+bitSize”）；
for（int k=0；k

您可以先尝试按字面意思应用您的推理，然后看看您最终得到了什么。另外，您是否考虑过使用

位集

，因为您似乎只使用0或1？OP没有显示出任何解决其自身问题的尝试。这个网站的目的不是让其他人做家庭作业。请不要用准备运行的代码回答此类问题。