如何在ArrayList（Java）中查找值之和？

我有一个ArrayList：

ArrayList<MSS_Vector_Alg> vectors = new ArrayList<MSS_Vector_Alg>();

如您所见，它有一个

（x，y，z）

值。我希望添加所有

x

值、

y

值和

z

值，这样我就可以得到一个（x-total，y-total，z-total）。我有办法做到吗

代码（供参考的类别）：

MSS\u向量\u Alg:

public class MSS_Vector_Alg {
        float x;
        float y;
        float z;

        int dimension;
        String unit;

        //basic ... assumes a 3D vector will be used
        public MSS_Vector_Alg(){
                this.x = 0;
                this.y = 0;
                this.z = 0;
                this.dimension = 3;
                this.unit = "unit";
        }
        //3D vector constructor
        public MSS_Vector_Alg(float x, float y, float z){
                this.x = x;
                this.y = y;
                this.z = z;
                this.dimension = 3;
                this.unit = "unit";
        }
        //2D vector constructor
        public MSS_Vector_Alg (float x, float y){
                this.x = x;
                this.y = y;
                this.dimension = 2;
                this.unit = "unit";
        }
        //1D vector constructor
        public MSS_Vector_Alg(float x){
                this.x = x;
                this.dimension = 1;
                this.unit = "unit";
        }

       // getter and setters
}

MSS\u向量\u数学：

public final class MSS_Vector_Math {

        // a list of possible method for various vector operations

        //addition

        public static MSS_Vector_Alg add(ArrayList<MSS_Vector_Alg> vectors){
                //TODO
                return null;
        }
        //opposite
        public static MSS_Vector_Alg opposite(MSS_Vector_Alg vector){

                float tempx;
                float tempy;
                float tempz;
                tempx = -vector.getx();
                tempy = -vector.gety();
                tempz = -vector.getz();
                MSS_Vector_Alg rev = new MSS_Vector_Alg(tempx, tempy, tempz);
                return rev;


        }
        //scalar multiplication
        public static MSS_Vector_Alg scalarMultiply(MSS_Vector_Alg vector, float scalar){
                float scax;
                float scay;
                float scaz;
                scax = vector.getx() * scalar;
                scay = vector.gety() * scalar;
                scaz = vector.getz() * scalar;

                MSS_Vector_Alg smul = new MSS_Vector_Alg(scax, scay, scaz);

                return smul;
        }
        //dot multiply
        public static Float dotMultiply (MSS_Vector_Alg vector1,MSS_Vector_Alg vector2 ){
                float dotx;
                float doty;
                float dotz;
                float dotmul;


                dotx = vector1.getx()*vector2.getx();
                doty = vector1.gety()*vector2.gety();
                dotz = vector1.getz()*vector2.getz();

                dotmul = dotx + doty + dotz;

                return dotmul;
        }

        //cross multiply
        public static MSS_Vector_Alg crossMultiply(MSS_Vector_Alg vector1,MSS_Vector_Alg vector2){
                float x1, y1, z1, x2, y2, z2, crossx, crossy, crossz;
                x1 = vector1.getx();
                y1 = vector1.gety();
                z1 = vector1.getz();
                x2 = vector2.getx();
                y2 = vector2.gety();
                z2 = vector2.getz();

                crossx = (y1*z2)-(z1*y2);
                crossy = (z1*x2)-(x1*z2);
                crossz = (x1*y2)-(y1*x2);

                MSS_Vector_Alg crsmul = new MSS_Vector_Alg(crossx, crossy, crossz);

                return crsmul;
        }

        //convert from polar to algebraic
        public static MSS_Vector_Alg convertPolarToAlgebraic(MSS_Vector_Pol polarVector){
                float conx, cony, conz, r;

                r = polarVector.getMagnitude();

                conx = ((float)r * (float)Math.cos(polarVector.getAlpha()));
                cony = ((float)r * (float)Math.cos(polarVector.getBeta()));
                conz = ((float)r * (float)Math.cos(polarVector.getGamma()));

                MSS_Vector_Alg conv = new MSS_Vector_Alg(conx, cony, conz);

                return conv;
        }
        //convert from algebraic to polar
        public static MSS_Vector_Pol convertAlgebraicToPolar(MSS_Vector_Alg algVector){
                float conx, cony, conz, r, alpha, beta, gamma;
                conx = algVector.getx();
                cony = algVector.gety();
                conz = algVector.getz();
                r = (float)Math.sqrt((conx*conx + cony*cony + conz*conz));
                alpha = (float)Math.acos(conx/r);
                beta = (float)Math.acos(cony/r);
                gamma = (float)Math.acos(conz/r);

                MSS_Vector_Pol polvec = new MSS_Vector_Pol(r, alpha, beta, gamma);

                return polvec;
        }

        //check validity of directional angles in 3D
        public static boolean checkAngles3D(float alpha, float beta, float gamma){
                //TODO
                return true;
        }
        //check validity of directional angle in 2D

        public static boolean checkAngle2D(float alpha){
                //TODO
                return true;
        }

        //check validity of directional angle in 1D
        public static boolean checkAngle1D(float alpha){
                //TODO
                return true;
        }
}

公共期末课程MSS\u向量\u数学{
//各种向量运算的可能方法列表
//加成
公共静态MSS\u向量\u Alg添加（数组列表向量）{
//待办事项
返回null；
}
//对立面
公共静态MSS_向量\u Alg对向（MSS_向量\u Alg向量）{
浮动节拍；
浮躁；
浮动温度；
tempx=-vector.getx（）；
tempy=-vector.gety（）；
tempz=-vector.getz（）；
MSS_向量_Alg rev=新的MSS_向量_Alg（tempx，tempy，tempz）；
返回版本；
}
//标量乘法
公共静态MSS_向量\u Alg标量多重（MSS_向量\u Alg向量，浮点标量）{
浮子；
浮标；
浮子；
scax=vector.getx（）*标量；
scay=vector.gety（）*标量；
scaz=vector.getz（）*标量；
MSS_Vector_Alg smul=新的MSS_Vector_Alg（scax、scay、scaz）；
返回smul；
}
//点乘
公共静态浮点点乘法（MSS_Vector_Alg vector1，MSS_Vector_Alg vector2）{
浮点数；
浮华的溺爱；
浮点数；
浮点数；
dotx=vector1.getx（）*vector2.getx（）；
doty=vector1.gety（）*vector2.gety（）；
dotz=vector1.getz（）*vector2.getz（）；
dotmul=dotx+doty+dotz；
返回dotmul；
}
//交叉乘法
公共静态MSS_向量\u Alg交叉乘法（MSS_向量\u Alg向量1，MSS_向量\u Alg向量2）{
浮点数x1、y1、z1、x2、y2、z2、crossx、crossy、crossz；
x1=vector1.getx（）；
y1=vector1.gety（）；
z1=vector1.getz（）；
x2=vector2.getx（）；
y2=vector2.gety（）；
z2=vector2.getz（）；
crossx=（y1*z2）-（z1*y2）；
crossy=（z1*x2）-（x1*z2）；
交叉z=（x1*y2）-（y1*x2）；
MSS_Vector_Alg crsmul=新的MSS_Vector_Alg（crossx、crossy、crossz）；
返回crsmul；
}
//从极坐标到代数坐标的转换
公共静态MSS_矢量Alg变换器极代数（MSS_矢量Pol极向量）{
浮球圆锥，圆锥Y，圆锥Z，r；
r=polarVector.getMagnitude（）；
conx=（（float）r*（float）Math.cos（polarVector.getAlpha（））；
cony=（（float）r*（float）Math.cos（polarVector.getBeta（））；
conz=（（float）r*（float）Math.cos（polarVector.getGamma（））；
MSS_向量_Alg conv=新的MSS_向量_Alg（conx，cony，conz）；
返回conv；
}
//从代数到极坐标的转换
公共静态MSS_向量_Pol变换代数ICtopolar（MSS_向量_algalgVector）{
浮点数conx、cony、conz、r、alpha、beta、gamma；
conx=algVector.getx（）；
cony=algVector.gety（）；
conz=algVector.getz（）；
r=（float）Math.sqrt（（conx*conx+cony*cony+conz*conz））；
alpha=（float）Math.acos（conx/r）；
beta=（float）Math.acos（cony/r）；
gamma=（浮点）数学acos（conz/r）；
MSS_矢量_Pol polvec=新的MSS_矢量_Pol（r，α，β，γ）；
返回polvec；
}
//检查3D中方向角的有效性
公共静态布尔校验角3d（浮点alpha、浮点beta、浮点gamma）{
//待办事项
返回true；
}
//检查二维方向角的有效性
公共静态布尔checkAngle2D（浮点alpha）{
//待办事项
返回true；
}
//检查1D方向角的有效性
公共静态布尔校验角1D（浮点alpha）{
//待办事项
返回true；
}
}

您是否尝试过在列表上迭代并添加这些数字

List<MSSVectorAlg> vectors = new ArrayList<MSSVectorAlg>();

int xTotal = 0, yTotal = 0, zTotal = 0;
for (MSSVectorAlg vector : vectors)
{
   xTotal  += vector.getX();
   yTotal  += vector.getY();
   zTotal  += vector.getZ();
}

List vectors=new ArrayList（）；
int-xTotal=0，yTotal=0，zTotal=0；
用于（MSSVectorAlg矢量：矢量）
{
xTotal+=vector.getX（）；
yTotal+=vector.getY（）；
zTotal+=vector.getZ（）；
}

最优雅的解决方案可能是使用Java流API：

  List<MSS_Vector_Alg> vectors = new ArrayList<MSS_Vector_Alg>();

  float sumOfXs = (float) vectors.stream().mapToDouble(mss -> mss.x).sum();
  float sumOfYs = (float) vectors.stream().mapToDouble(mss -> mss.y).sum();
  float sumOfZs = (float) vectors.stream().mapToDouble(mss -> mss.z).sum();

List vectors=new ArrayList（）；
float sumOfXs=（float）vectors.stream（）.mapToDouble（mss->mss.x.sum（）；
float sumOfYs=（float）vectors.stream（）.mapToDouble（mss->mss.y.sum（）；
float sumOfZs=（float）vectors.stream（）.mapToDouble（mss->mss.z.sum（）；

遍历列表以获得MSS_Vector_Alg，并为每个对象添加x，y，zFernando，您知道“-”不能是java标识符的一部分，是吗？是的，我使用它与他的变量hahah有一些相似之处（已经删除了类名中的“u”，只是为了给它上色）

  List<MSS_Vector_Alg> vectors = new ArrayList<MSS_Vector_Alg>();

  float sumOfXs = (float) vectors.stream().mapToDouble(mss -> mss.x).sum();
  float sumOfYs = (float) vectors.stream().mapToDouble(mss -> mss.y).sum();
  float sumOfZs = (float) vectors.stream().mapToDouble(mss -> mss.z).sum();