后续：嵌套循环和数组答案

【问题标题】：Follow-up: nested loops and arrays后续：嵌套循环和数组
【发布时间】：2015-12-04 07:38:54
【问题描述】：

我仍在努力实现上述问题中所述的相同目标。基本上我的代码现在看起来像这样：

for(int ac = 0; ac < gravityObject.length; ac++){
        gravField[ac].setVector(0,0);
        System.out.println(ac);
        for(int ad=0;ad<gravityObject.length;ad++){
            System.out.println(ad);
            if(ac!=ad){
                gravField[ac].increaseBy(gravityObject[ac].aDueToGravity(planetMass[ad], position[ad], position[ac]));
            }
            else{
                //do nothing
            }
            gravField[ac].print();
        }
    }

这很烦人，我不明白为什么会这样！

示例：我想计算由于太阳和月亮引起的地球加速度。所以我有 double[] planetMass = {earthMass, sunMass, moonMass}，粒子对象数组 Particle[] planets = {earth, sun, moon} 和他们经历的重力加速度数组，这些还没有计算： PhysicsVector[] 重力场 = {earthGrav,sunGrav,moonGrav}。

我的循环是用来填充这个数组的。我想对 sunGrav 和 moonGrav 求和以找到地球的加速度，并将结果存储在 earthGrav 中，所以在 gravField[0] 中。然后earthGrav+moonGrav，这个应该存储为gravField[1]。

我的循环正确计算了gravField[0]、gravField[1] 和gravField[2] 的值，然后不幸地将所有gravField[] 设置为等于gravField[2]。

这大概是因为我一直将 gravField[ac] 重置为零。但如果我不这样做，那么我就不会得到正确的值。我的主要课程的其余部分（问题肯定是循环）：公共静态 PhysicsVector[] copyArray(PhysicsVector[] a) { int 长度 = a.length; PhysicsVector[] 复制 = new PhysicsVector[length]; System.arraycopy(a, 0, 复制, 0, 长度); 返回副本； }

public static double sumArray(double[] p){
    double sum = 0;
    for(int z= 0; z < p.length; z++){
        sum += p[z];
    }
    return sum;
}

public static PhysicsVector[] subtract(PhysicsVector[] diff, PhysicsVector g){
    for (int ab=0; ab<diff.length;ab++){ 
        diff[ab].decreaseBy(g);
    }
    return diff;
}   
public static void main(String[] args) throws IOException{

    java.io.File file = new java.io.File("output.txt" );
    java.io.PrintWriter n = new PrintWriter(file);

    //Initialise variables here
    PhysicsVector earthInitialPos = new PhysicsVector();
    PhysicsVector earthInitialV = new PhysicsVector();
    PhysicsVector sunInitialV = new PhysicsVector();
    PhysicsVector sunInitialPos = new PhysicsVector();
    PhysicsVector moonInitialPos = new PhysicsVector();
    PhysicsVector moonInitialV=new PhysicsVector();

    Scanner scanner = new Scanner(System.in);       
    System.out.println("Please enter the size of the time step:");
    double timeStep = scanner.nextDouble();

    //SET PLANETS' INITIAL POSITIONS
    //Set Earth's initial position and initial velocity
    earthInitialPos.setVector(1.4960*Math.pow(10,11),0);
    earthInitialV.setVector(0,29785.5889);
    //Set the sun's initial position
    sunInitialPos.setVector(0,0);
    sunInitialV.setVector(0,-0.08945);      //v = 2*pi*R/T
    //Set the moon's initial position and velocity
    moonInitialPos.setVector(3.844*Math.pow(10,8),0);
    moonInitialPos.increaseBy(earthInitialPos);
    moonInitialV.setVector(0,1023.2195);
    moonInitialV.increaseBy(earthInitialV);

    //CREATE GRAVFIELD OBJECTS
    GravField sunGravField = new GravField(sunMass, sunRadius, sunInitialPos);
    GravField earthGravField = new GravField(earthMass, earthRadius, earthInitialPos);
    GravField moonGravField = new GravField(moonMass, moonRadius, moonInitialPos);

    //CREATE PARTICLE OBJECTS   
    Particle earth = new Particle(earthMass, earthInitialPos, earthInitialV);
    Particle sun = new Particle(sunMass, sunInitialPos, sunInitialV); 
    Particle moon = new Particle(moonMass, moonInitialPos, moonInitialV);

    double time = 0;
    double finalTime = 31557600;            //Run for one earth year

    //Initialise newV and set equal to initialV
    PhysicsVector newV = new PhysicsVector();
    newV = earthInitialV;
    PhysicsVector sunNewV = new PhysicsVector();
    sunNewV = sunInitialV;
    PhysicsVector moonNewV = new PhysicsVector();
    moonNewV = moonInitialV;

    PhysicsVector newSunGrav = new PhysicsVector();
    PhysicsVector newEarthGrav = new PhysicsVector();
    PhysicsVector newMoonGrav = new PhysicsVector();

    GravField[] gravityObject = {earthGravField, sunGravField, moonGravField};
    PhysicsVector[] position = {earthInitialPos, sunInitialPos, moonInitialPos}; 
    PhysicsVector[] velocity = {newV, sunNewV, moonNewV};
    PhysicsVector[] gravField = {zero, zero, zero};
    double[] planetMass = {earthMass, sunMass, moonMass};
    Particle[] planets = {earth, sun, moon};
    PhysicsVector a = new PhysicsVector(0,0);

    //Calculate the centre of mass and subtract position from positions of planets, so c.o.m is at origin
    PhysicsVector centreOfMass = new PhysicsVector();
    centreOfMass = earth.centreOfMass(planetMass, position);
    position = SolarSim.subtract(position, centreOfMass);

    //Calculate centre of mass velocity and subtract from planet velocities
    PhysicsVector centreOfMassVelocity = new PhysicsVector();
    centreOfMassVelocity = earth.cOMVel(planetMass, velocity);
    velocity = SolarSim.subtract(velocity, centreOfMassVelocity);

    //Calculate fields of planets
    for(int ac=0; ac<gravityObject.length; ac++){
        gravField[ac].setVector(0,0);
        System.out.println(ac);
        for(int ad=0;ad<gravityObject.length;ad++){
            System.out.println(ad);
            if(ac!=ad){
                //gravField[ac].increaseBy(gravityObject[ac].aDueToGravity(planetMass[ad], position[ad], position[ac]));
                a.increaseBy(gravityObject[ac].aDueToGravity(planetMass[ad], position[ad], position[ac]));
                gravField[ac] = a;
            }
            else{
                //do nothing
            }
            gravField[ac].print();
        }
    }

    System.out.println(Arrays.toString(gravField));
    PhysicsVector[] newP = new PhysicsVector[position.length];
    PhysicsVector[] newGrav = {zero,zero,zero};
    PhysicsVector[] newVel = new PhysicsVector[velocity.length];

    PhysicsVector sum1 = new PhysicsVector(0,0);
    PhysicsVector sum2 = new PhysicsVector(0,0);
    PhysicsVector sum3 = new PhysicsVector(0,0);

    //do{
        PhysicsVector[] y = new PhysicsVector[gravField.length];
        y=copyArray(gravField);
        PhysicsVector[] z = new PhysicsVector[gravField.length];
        z=copyArray(gravField);

        for(int i=0; i<planets.length;i++){
            sum1.setVector(0,0);    
            for(int s=0;s<z.length;s++){

                if(i!=s){
                    sum1.increaseBy(z[s]); 
                }
                else{
                    sum1.scale(1);  
                }

            }
            newP[i] = planets[i].updatePosition(position[i], velocity[i], timeStep, sum1);
        }
        newP[2].increaseBy(newP[0]);
        //Calculate the centre of mass and subtract position from positions of planets, so c.o.m is at origin
        centreOfMass = earth.centreOfMass(planetMass, newP);
        newP = SolarSim.subtract(newP, centreOfMass);

        for(int j=0; j<gravityObject.length; j++){    

            for(int l=0;l<gravityObject.length;l++){

                if(j!=l){

                newGrav[j].increaseBy(gravityObject[j].aDueToGravity(planetMass[j], position[j], position[l]));
                }
                else{

                }
            }
        }

        for(int k=0; k<planets.length; k++){
            sum2.setVector(0,0);
            sum3.setVector(0,0);
            for(int m = 0; m<y.length;m++){
                if(k!=m){
                    sum2.increaseBy(y[m]);
                    sum3.increaseBy(newGrav[m]);
                }
                else{
                    sum2.scale(1);
                    sum3.scale(1);
                }
            }
            newVel[k] = planets[k].updateVelocity(velocity[k], timeStep, sum2, sum3);
        }
        newVel[2].increaseBy(newVel[0]);
        //Calculate centre of mass velocity and subtract from planet velocities
        centreOfMassVelocity = earth.cOMVel(planetMass, newVel);
        newVel = SolarSim.subtract(newVel, centreOfMassVelocity);

        gravField = copyArray(newGrav);

        time+=timeStep;

        //n.println(e+" "+z);
        //n.println(g+" "+h);

    //}while (time<=finalTime);
    System.out.println(Arrays.toString(newP));

    n.close();
}

}

【问题讨论】：

你对你的代码有什么期望？
@Abdelhak 这里的代码：gravityObject[ac].aDueToGravity(planetMass[ad], position[ad], position[ac] 代表加速度。我想对所有广告的加速度求和并存储它们在 gravField[ac] 中。
@Abdelhak 提供更广泛的示例会有帮助吗？
尝试把你所有的代码
@Abdelhak 我已经添加了一个我想要它做的示例，并添加了我的主要课程的其余部分。

标签： java arrays loops

【解决方案1】：

尝试在单独的步骤中将 GravField 归零：

for(int ac = 0; ac < gravityObject.length; ac++){
    gravField[ac].setVector(0,0);
}

for(int ac = 0; ac < gravityObject.length; ac++){
    System.out.println(ac);
    /// the rest of your code as above, without setVector(0,0)

【讨论】：

告诉我 ac 已经定义了。我应该从第二个 for 循环中删除 int 声明，还是将其更改为其他变量，例如 h？
将其更改为另一个变量名应该可以工作，但奇怪的是，上述内容也应该可以工作，因为“ac”应该被限定为“for”循环。您正在关闭第一个“for”循环，并带有一个闭合的花括号 } ？
无论哪种方式，核心思想是首先将所有内容归零，然后分别使用嵌套循环将加速度值添加到其中。祝你好运！
哦，是的，我使用的是 ) 而不是 }。虽然它仍然不起作用，因为它可以编译，但是循环没有链接，因此它将gravField [0]和gravField [1]和gravField [2]相加。为了工作，每次运行后都必须将其归零，但这意味着我需要的值不会被存储。
查看您的原始代码，您似乎将所有 3 个gravField 成员设置为对同一对象的引用：PhysicsVector[] GravField = {zero, zero, zero};也许这就是他们被总结的原因。尝试将每个对象设置为一个新对象，可能为：PhysicsVector[] gravField = {new PhysicsVector(), new PhysicsVector(), new PhysicsVector()};