我对一个代码有问题，数组 matriarcas 不要将结果保存在while循环中。

import java.util.ArrayList;

public class Swarm {
  //private instancias instance = instancias.getInstance();
  //private int id = instance.ID;
  private final int type = instancias.type; 
    private final int instance = instancias.instance[instancias.type];

  private final int nClanes =  4;
    private final int nElefantes = 80;
  private final int maxGen = 20;
    private final float alpha = 0.25f;
    private final float beta = 0.05f;
  private final float gamma = 0.015f;
    private final float r = (float)(2 * Distribution.uniform() - 1);

    private static ArrayList<Object> clanes = null; //Agrupaciones de manadas
    private ArrayList<Elefante> manada = new ArrayList<>(); // Agrupaciones de elefantes, el tamaño de esta es nElefantes/nClanes
  private final ArrayList<Elefante> matriarcas = new ArrayList<>(); //Es el mejor fitness de cada clan 
    private final ArrayList<Elefante> centros = new ArrayList<>(); //Es un elefante el cual indica el centro, se saca como un promedio, su tamaño es clanes.size
  private Elefante b;

    public void execute() {
        initRandom();
        run();
    }

    private void initRandom() {
      clanes = new ArrayList<>();
        Elefante e = null;
        for (int i = 1; i <= nClanes; i++) { //Bucle para añadir manadas al arreglo clanes 
            for (int j = 1; j <= nElefantes/nClanes; j++) { //Bucle para añadir elefantes al arreglo manada
                do {
                    e = new Elefante();
                } while (!e.isFeasible());
                manada.add(e); //Si el elefante es factible se añade a la manada
            }
            matriarcas.add(e);

            clanes.add(manada); //Se agrega la manada al clan
            manada = new ArrayList<>(); //Se limpia el arreglo manada para volverlo a usar

        }
        for( int i = 0; i < nClanes;i++) {
            matriarcas.get(i).copy((Elefante)((ArrayList)clanes.get(i)).get(0)); // Se deja al primer elefante de la manada como matriarca para compararlo abajo 

            for (int j = 0; j < nElefantes/nClanes; j++) {
                if (((Elefante)((ArrayList)clanes.get(i)).get(j)).isBetterThan(matriarcas.get(i))) {
                    matriarcas.get(i).copy((Elefante)((ArrayList)clanes.get(i)).get(j));
                }
            }

        }

        Elefante c;
        int suma;
        int[] posicion; 

        for (int i = 0; i < nClanes; i++) {
            do {
                c = new Elefante();
                suma = 0;
                posicion = new int[c.dimension]; 
                for (int k = 0; k < c.dimension ; k++) {
                    for (int j = 0; j < clanes.size(); j++) {
                        suma = suma + ((Elefante)((ArrayList)clanes.get(i)).get(j)).posicion[k];
                    }
                    posicion[k] = BinarizationStrategy.toBinary(suma / (clanes.size()));

                }
                c.setPosicion(posicion);
            } while(!c.isFeasible());
            centros.add(c);
        }
    }

    private void run() {
    int t = 1;

        while (t <= maxGen) {

            for (int i = 0; i < nClanes; i++) {

                if (!((ArrayList)clanes.get(i)).isEmpty()) {

                    for (int j = 0; j < nElefantes/nClanes -1; j++) {
                            //burbuja 
              if (!((Elefante)((ArrayList)clanes.get(i)).get(j)).isBetterThan(((Elefante)((ArrayList)clanes.get(i)).get(j + 1)))) {

                Elefante tmp = ((Elefante)((ArrayList)clanes.get(i)).get(j));

              ((Elefante)((ArrayList)clanes.get(i)).get(j)).copy(((Elefante)((ArrayList)clanes.get(i)).get(j + 1)));

                ((Elefante)((ArrayList)clanes.get(i)).get(j + 1)).copy(tmp);

                        }   
                }

        }

                 if(
          ((Elefante)((ArrayList)clanes.get(i)).get(0)).isBetterThan(matriarcas.get(i))
         )
         {

         matriarcas.get(i).copy((Elefante)(((ArrayList)clanes.get(i)).get(0)));

         }

                for (int j = 0; j < nElefantes/nClanes; j++) {
                    do{ ((Elefante)((ArrayList)(clanes.get(i))).get(j)).actualizar(matriarcas.get(i), alpha, beta, gamma, (Elefante)centros.get(i), r);
          }while(!((Elefante)((ArrayList)(clanes.get(i))).get(j)).isFeasible());
                }

                ((Elefante) ((ArrayList)clanes.get(i)).get(clanes.size() - 1)).separador();

    }

    t++;
    }
    b = matriarcas.get(0);
    b.copy(matriarcas.get(0));
    for (int i = 1; i < nClanes; i++) {
        if(
          matriarcas.get(i).isBetterThan(b)
         ){
          b.copy(matriarcas.get(i));
         }
    }
  System.out.println("Matriarca final: " + b + " Valor optimo: " + instancias.optimo[type][instance]);
  }

}

方法从类elefante调用：

import java.util.Arrays;
import java.util.List;

public class Elefante {

  // private KP_xd instance = KP_xd.getInstance();
    // private int id = instance.ID;
   //int dimension = instance.dimension[id];
  private final int type = instancias.type; 
    private final int instance = instancias.instance[instancias.type];
  protected final int dimension = instancias.dimension[type][instance]; 

  public int [] posicion  = new int[dimension];

  public Elefante() {

        for (int j = 0; j < dimension; j++) {
            posicion[j] = Distribution.uniform(2);
        }
    }

  protected boolean isBetterThan(Elefante e) {
        return fitness() > e.fitness();
    }

private double fitness() { 
        double suma = 0; 
        for (int j = 0; j < dimension; j++) {
            suma += posicion[j] * instancias.valores[type][instance][j];
        }
        return suma;
    }

protected boolean isFeasible() {
    return type == 0 ? isFeasibleCapability() : isFeasibleCapabilityMultidimensional();
  }

 private boolean isFeasibleCapability() {
    double suma = 0; 
    for (int j = 0; j < dimension; j++) {
      suma += posicion[j] * instancias.pesos[type][instance][0][j];
        }
      return suma <= instancias.capacidad[type][instance][0];
    }

    private boolean isFeasibleCapabilityMultidimensional() {
    int suma; 
        int i = 0;
        boolean feasible = true;
        while (i < instancias.numero_mochilas[type][instance] && feasible) {
            suma = 0; 
            for (int j = 0; j < dimension; j++) {
                suma += posicion[j] * instancias.pesos[type][instance][i][j];
            }
            feasible = suma <= instancias.capacidad[type][instance][i];
            i++;
        }
        return feasible;
    }

  //   public double fitness() {
  //       double suma = 0;
  //       for (int j = 0; j < dimension; j++) {
  //           suma += posicion[j] * instance.valores[id][j];
  //       }
  //       return suma;
  //   }

  //   public boolean isFeasible() {

  //       double peso = 0;
  //       for (int j = 0; j <   dimension; j++) {
  //           peso += posicion[j] * instance.pesos[id][0][j];
  //       }
  //       return peso <= instance.capacidad[id][0];
  //   }

    // private boolean isFeasibleMKP() {
  //   int suma; 
    //  int i = 0;
    //  boolean feasible = true;
  //       while (i < MKP_xd.numero_mochila[type][instance] && feasible) {
    //      suma = 0; 
    //      for (int j = 0; j < dimension; j++) {
  //            suma += x[j] * instancias.weights[type][instance][i][j];
    //      }
    //      feasible = suma <= instancias.b[type][instance][i];
    //      i++;
  //       }
    //  return feasible;
  //   }

    protected void actualizar(Elefante m, float alpha, float beta, float gamma, Elefante c, float r) {
        for (int j = 0; j < dimension; j++) {
            posicion[j] = BinarizationStrategy.toBinary(posicion[j] + 
                        alpha * (m.posicion[j] - posicion[j]) + 
                        beta * (c.posicion[j] - posicion[j]) + gamma * r);

        }
    }
  private float optimal() {
        return instancias.optimo[type][instance];
    }

    protected void copy(Object obj) {
        if (obj instanceof Elefante) {
            System.arraycopy(((Elefante)obj).posicion, 0, this.posicion , 0, dimension);
        }
    }

     protected void setPosicion(int[] p) {
        System.arraycopy(this.posicion, 0, p, 0, dimension);
     }

    protected void separador() {
        do {
            for (int j = 0; j < dimension; j++) {
                posicion[j] = Distribution.uniform(2);
            }
        } while(!isFeasible());
    } 
  @Override
  public String toString(){
    return String.format("%f", fitness());
  } 
}

我认为这是一个记忆问题，但我不知道它在哪里。