Java中的求和（内置方法）的实现？答案

【问题标题】：Sum in Java (built in method)'s Implementation?Java中的求和（内置方法）的实现？
【发布时间】：2021-04-10 23:59:53
【问题描述】：

大家好，新年快乐。

我来自 matlab 世界，一年前开始用 java 编码。我正在解决可能很容易但请耐心等待的问题！这是matlab的代码： state 是 3d 数组的变量，其大小为：2x4x64。 state 值是：（这就是我在matlab的编辑器上得到的）

state(:,:,1) =

     1     0     0     0
     2     0     1     1


state(:,:,2) =

     3     0     1     0
     4     0     0     1


state(:,:,3) =

     5     0     1     1
     6     0     0     0


state(:,:,4) =

     7     0     0     1
     8     0     1     0


state(:,:,5) =

     9     0     1     1
    10     0     0     0


state(:,:,6) =

    11     0     0     1
    12     0     1     0


state(:,:,7) =

    13     0     0     0
    14     0     1     1


state(:,:,8) =

    15     0     1     0
    16     0     0     1


state(:,:,9) =

    17     0     0     0
    18     0     1     1


state(:,:,10) =

    19     0     1     0
    20     0     0     1


state(:,:,11) =

    21     0     1     1
    22     0     0     0


state(:,:,12) =

    23     0     0     1
    24     0     1     0


state(:,:,13) =

    25     0     1     1
    26     0     0     0


state(:,:,14) =

    27     0     0     1
    28     0     1     0


state(:,:,15) =

    29     0     0     0
    30     0     1     1


state(:,:,16) =

    31     0     1     0
    32     0     0     1


state(:,:,17) =

    33     0     0     1
    34     0     1     0


state(:,:,18) =

    35     0     1     1
    36     0     0     0


state(:,:,19) =

    37     0     1     0
    38     0     0     1


state(:,:,20) =

    39     0     0     0
    40     0     1     1


state(:,:,21) =

    41     0     1     0
    42     0     0     1


state(:,:,22) =

    43     0     0     0
    44     0     1     1


state(:,:,23) =

    45     0     0     1
    46     0     1     0


state(:,:,24) =

    47     0     1     1
    48     0     0     0


state(:,:,25) =

    49     0     0     1
    50     0     1     0

state(:,:,26) =

    51     0     1     1
    52     0     0     0


state(:,:,27) =

    53     0     1     0
    54     0     0     1


state(:,:,28) =

    55     0     0     0
    56     0     1     1


state(:,:,29) =

    57     0     1     0
    58     0     0     1


state(:,:,30) =

    59     0     0     0
    60     0     1     1


state(:,:,31) =

    61     0     0     1
    62     0     1     0


state(:,:,32) =

    63     0     1     1
    64     0     0     0


state(:,:,33) =

     1     1     1     1
     2     1     0     0


state(:,:,34) =

     3     1     0     1
     4     1     1     0


state(:,:,35) =

     5     1     0     0
     6     1     1     1


state(:,:,36) =

     7     1     1     0
     8     1     0     1


state(:,:,37) =

     9     1     0     0
    10     1     1     1


state(:,:,38) =

    11     1     1     0
    12     1     0     1


state(:,:,39) =

    13     1     1     1
    14     1     0     0


state(:,:,40) =

    15     1     0     1
    16     1     1     0


state(:,:,41) =

    17     1     1     1
    18     1     0     0


state(:,:,42) =

    19     1     0     1
    20     1     1     0


state(:,:,43) =

    21     1     0     0
    22     1     1     1


state(:,:,44) =

    23     1     1     0
    24     1     0     1


state(:,:,45) =

    25     1     0     0
    26     1     1     1


state(:,:,46) =

    27     1     1     0
    28     1     0     1


state(:,:,47) =

    29     1     1     1
    30     1     0     0


state(:,:,48) =

    31     1     0     1
    32     1     1     0


state(:,:,49) =

    33     1     1     0
    34     1     0     1


state(:,:,50) =

    35     1     0     0
    36     1     1     1


state(:,:,51) =

    37     1     0     1
    38     1     1     0


state(:,:,52) =

    39     1     1     1
    40     1     0     0


state(:,:,53) =

    41     1     0     1
    42     1     1     0


state(:,:,54) =

    43     1     1     1
    44     1     0     0


state(:,:,55) =

    45     1     1     0
    46     1     0     1


state(:,:,56) =

    47     1     0     0
    48     1     1     1


state(:,:,57) =

    49     1     1     0
    50     1     0     1


state(:,:,58) =

    51     1     0     0
    52     1     1     1


state(:,:,59) =

    53     1     0     1
    54     1     1     0


state(:,:,60) =

    55     1     1     1
    56     1     0     0


state(:,:,61) =

    57     1     0     1
    58     1     1     0


state(:,:,62) =

    59     1     1     1
    60     1     0     0


state(:,:,63) =

    61     1     1     0
    62     1     0     1


state(:,:,64) =

    63     1     0     0
    64     1     1     1
%%%%%%%%%%%%%%%%%%%

revealed =[1 0];
tmp=[0,0];
for m=1:2
tmp[1]=sum(abs(state(l, 3:4 ,j)-revealed)) % here  state(m, 3:4 ,j) is actually the 3rd and 4th columns substracting from them the array revealed at every row (m=1, 2) of given j.
end
so at the end it returns tmp.

对于不了解 matlab 的人来说，有一个大小为 2x4x64 的数组状态和 state(l, 3:4 ,j) 根据 j 给我两列值，然后我们减去从那时显示的数组和我们之后做 abs 然后对数组结果求和。例如：状态 (m, 3:4 , 1) 。 J=1 给我 [0 0] 和 [1 1] 对于 m=1 ， m=2 在第三和第四列。所以我每减去一个 m 就显露出来 [1 0] 来自第三列和第四列的两个值根据m。所以在这里 m=1 我们有 [0 0] 所以 [0 0] - 显示 => [0 0]-[1 0] => [-1 0] 我们做 abs([-1 0]) 所以我们得到 [1 0] 然后我们求和，它是 1+0 => 1。在 m=1 我们得到 [1 1] 所以 [1 1]-[1 0] => [1 0] 我们在这个数组上做 abs => [1 0] 然后我们做 sum 1+0 => 1 .

我正在尝试在 java 中做同样的事情/同样的概念（将此代码 matlab 转换为 java）。所以我所做的是：

int[64][2][4] state=
{
{{ 1    , 0 ,    0 ,    0},
 { 2    , 0   ,  1,     1 }},

    {{ 3 ,    0 , 1 ,    0},
    {4   ,  0  ,   0  ,   1}},

    {{  5   ,  0 ,    1  ,   1},
    {6   ,  0 ,    0    , 0}},

    {{ 7    , 0   ,  0    , 1},
    { 8 ,    0  ,   1 ,    0 }}


   { {9     ,0  ,   1   ,  1},
    {10  ,   0   ,  0    , 0}},

    { { 11  ,   0   ,  0 ,    1},
      {12   ,  0   ,  1  ,   0}},




    { { 13  ,   0  ,   0  ,  0},
    {14   ,  0    , 1  ,   1}},




    { { 15  ,   0   ,  1 ,    0},
    { 16  ,   0  ,   0  ,   1} },


    {{17  ,   0  ,   0  ,   0},
    {18  ,   0  ,   1 ,    1 }},

    {{19  ,   0  ,   1   ,  0},
     {20  ,   0  ,   0  ,   1}},

    {{21   ,  0  ,   1 ,    1},
    { 22   ,  0   ,  0 ,    0}},


    { { 23 ,    0 ,    0,     1} ,
    {24  ,   0  ,   1  ,   0}},


    { {25  ,   0  ,   1 ,    1},
    {26   ,  0   ,  0  ,   0}},


    { {27   ,  0  ,   0 ,    1},
      {28  ,   0  ,   1  ,   0}},

    {{29   ,  0  ,   0  ,   0},
     {30  ,   0 ,    1 ,    1}},

    {{ 31   ,  0    , 1  ,   0},
     {32   ,  0  ,  0   ,  1}},


    { { 33 ,    0   ,  0 ,    1},
    {34   ,  0  ,   1 ,    0} },

    {{35  ,   0   ,  1   ,  1},
    {36  ,   0    , 0   ,  0}},

    {{ 37  ,   0  ,   1 ,    0},
     {38   ,  0  ,   0  ,   1}},

    {{39   ,  0  ,   0  ,   0},
     { 40   ,  0  ,   1  ,   1}},


    {{41  ,   0   ,  1 ,    0},
    { 42  ,   0  ,   0  ,   1}},


    {{ 43  ,   0  ,   0 ,    0},
     { 44  ,  0   ,  1  ,   1}}


    {45 ,    0  ,   0  ,   1},
    {46  ,   0  ,   1  ,   0} },


   { { 47   ,  0 ,    1  ,   1 },
     { 48   ,  0  ,   0  ,   0 } },


    {{ 49  ,   0  ,   0  ,   1 },
     { 50  ,   0   ,  1   ,  0 }},




  { { 51   ,  0    , 1 ,    1 },
    {52   ,  0   , 0  ,  0} },



    { { 53  ,   0,     1  ,   0 },
      {54   ,  0 ,   0  ,  1} },



    { { 55  ,   0   ,  0   ,  0 },
      { 56  ,   0   ,  1  ,   1} },


   { {57  ,   0  ,   1  ,   0},
     {58  ,   0  ,   0  ,   1} },



   { { 59   ,  0   ,  0 ,    0 },
      { 60   ,  0   ,  1  ,   1} },



   { { 61 ,    0 ,    0  ,   1 },
     { 62   ,  0  ,   1  ,   0} },



  { { 63   ,  0  ,   1 ,   1},
    { 64  ,  0  ,   0 ,   0 } },
};



 public class GlobalMember
    {
     int[] revealed =[1 0];
     int[] tmp= {0,0};
   for(int j=0 ; j<64 ; j++)  
     { for (int m = 0 ; l < 2 ; l++)
       {      
           tmp[l] = 
             IntStream.of((Math.abs(state[m, 3 : 4, j] - revealed))).sum();
             //note that I always just check 3rd and 4th columns values which 
            //they are implicitly an array with two element at every row of 
           //the two rows at every j(j is range from 0 to 64).
       }
     }
    }

但听起来我遗漏了一些东西，它根本无法编译，谁能帮帮我我如何在java中实现这个代码matlab？我的意思是在java中实现相同的matlab代码概念。

我为此苦苦挣扎了大约一周，但我不明白问题到底出在哪里。

非常感谢。

【问题讨论】：

数组初始值设定项中的数字应该用逗号分隔，而不仅仅是空格。
您会惊讶于用逗号分隔数字可以消除多少错误
我的问题不是逗号，更多的是函数本身，我会修复逗号问题，但距离问题还很远。
我也更新了代码。
@ErwinBolwidt 有什么帮助吗？

标签： java arrays matlab arraylist collections

【解决方案1】：

你必须修复初始化sintax（逗号分隔值），这里问过类似的问题Syntax for creating a two-dimensional array

我猜你应该这样做：

int[64][2][4] state=
{
{{1,0,0,0},
{2,0,1,1}},
{{3,0,1,0},
...

【讨论】：

但我在代码中所做的与您假设的相同..
有什么帮助吗？
我更新了我的线程/代码，你能帮帮我吗？！

【解决方案2】：

首先让我们熟悉一下基础知识。让我们从二维数组开始。

a) 二维数组

想象二维数组不是数字网格，而是一维数组的层，因为这些层中的每一层都可以有一个任意长度的一维数组，让我们看一个例子

 //This 2D array has 3 layers, each layer is denoted using {} brackets

 int[][] test={
               {1,2}            //Layer 0 has 2 elements
              ,{3,4,5}          //Layer 1 has 3 elements  
              ,{6,7,8,9}        //Layer 2 has 4 elements
             };

要查询此代码，您可以这样做

int layers=test.length;  //This gives us the total layers in the 2D array
System.out.println(layers);   
for(int i=0;i<layers;i++){System.out.println(test[i].length);}//This queries the number of elements in each layer

输出：

3  //Number of layers=3
2  //Layer 0 has 2 elements
3  //Layer 1 has 3 elements
4  //Layer 2 has 4 elements

你也可以像这样初始化一个二维数组

int rows=2;
int cols=3;
int[][] test=new int[rows][cols];

但是，您可能已经从上面猜到了一个限制，那就是您只能以网格方式初始化您的 2D 数组。层数为行，每层中每个一维数组的长度为列。

要遍历每个元素，您可以这样做

for(int layer=0;layer<test.length;layer++)  //iterate over each layer
{
 for(int i=0;i<test[layer].length;i++)      //for each layer iterate over all elements in that layer
 {
  int element=test[layer][i];
 }
}

b) 3D 阵列

现在就像 2D 数组包含多层 1D 数组 3D 数组包含多层 2D 数组，让我们看一个示例

 int[][][] test=
  {
   {                     //This is layer 0
     {0,1}
    ,{2,3,4}
   }      
   ,     
   {                     //This is layer 1
     {5,6}
    ,{7,8,9}
    ,{10,11,12}
   }     
   ,      
   {                      //This is layer 2
     {13,14}
    ,{15,16,17}
    ,{18,19,20,21}
    ,{22,23,24,25,26}
   }
  };

你也可以像这样初始化一个 3D 数组

int layers=3;
int rows=4;
int col=5;
int[][][] test=new int[layers][rows][col];

再次限制每个二维数组层必须以网格方式初始化

事实上，你可以像这样从这个 3D 数组中的任何层引用一个 2D 数组

int[][] test2=test[0]; //get the 2D array stored in layer 0

还可以遍历这个 3D 数组中的每个元素，您已经挖掘了所有层

for(int layer2D=0;layer2D<test.length;layer2D++)  //Iterate over every 2D array layer in this 3D array
{
 for(int layer1D=0;layer1D<test[layer2D].length;layer1D++)  //iterate over every 1D layer of this current 2D array
 {
  for(int element=0;element<test[layer2D][layer1D].length;element++) //finally iterate over every element of this current 1D layer or 1D array
  {
   int value=test[layer2D][layer1D][element];
    
  }
 }
}

好吧，让我们现在解决您的问题。

1) 修复你的数组

由于您使用方法一初始化 3D 数组，因此您无需指定长度。这是你的最终数组

int[][][] state=              //No need to specify lengths just use empty brackets
  {
   {                          //Layer 0
    {1    , 0 ,    0 ,    0},
    {2    , 0   ,  1,     1 }
   }
   ,
   {                          //Layer 1 and so on
    {3 ,    0 , 1 ,    0},
    {4   ,  0  ,   0  ,   1}
   }
   ,
   {
    {5   ,  0 ,    1  ,   1},
    {6   ,  0 ,    0    , 0}
   }
   ,
   {
    {7    , 0   ,  0    , 1},
    {8 ,    0  ,   1 ,    0 }
   }
   ,
   { 
    {9     ,0  ,   1   ,  1},
    {10  ,   0   ,  0    , 0}
   }
   ,
   { 
    {11  ,   0   ,  0 ,    1},
    {12   ,  0   ,  1  ,   0}
   }
   ,
   { 
    {13  ,   0  ,   0  ,  0},
    {14   ,  0    , 1  ,   1}
   }
   ,
   { 
    {15  ,   0   ,  1 ,    0},
    {16  ,   0  ,   0  ,   1} 
   }
   ,
   {
    {17  ,   0  ,   0  ,   0},
    {18  ,   0  ,   1 ,    1 }
   }
   ,
   {
    {19  ,   0  ,   1   ,  0},
    {20  ,   0  ,   0  ,   1}
   }
  ,
  {
   {21   ,  0  ,   1 ,    1},
   {22   ,  0   ,  0 ,    0}
  }
  ,
  { 
   {23 ,    0 ,    0,     1},
   {24  ,   0  ,   1  ,   0}
  }
  ,
  { 
   {25  ,   0  ,   1 ,    1},
   {26   ,  0   ,  0  ,   0}
  }
  ,
  { 
   {27   ,  0  ,   0 ,    1},
   {28  ,   0  ,   1  ,   0}
  }
  ,
  {
   {29   ,  0  ,   0  ,   0},
   {30  ,   0 ,    1 ,    1}
  }
  ,
  {
   {31   ,  0    , 1  ,   0},
   {32   ,  0  ,  0   ,  1}
  }
  ,
  { 
   {33 ,    0   ,  0 ,    1},
   {34   ,  0  ,   1 ,    0} 
  }
  ,
  {
   {35  ,   0   ,  1   ,  1},
   {36  ,   0    , 0   ,  0}
  }
  ,
  {
   {37  ,   0  ,   1 ,    0},
   {38   ,  0  ,   0  ,   1}
  }
  ,
  {
   {39   ,  0  ,   0  ,   0},
   {40   ,  0  ,   1  ,   1}
  }
  ,
  {
   {41  ,   0   ,  1 ,    0},
   {42  ,   0  ,   0  ,   1}
  }
  ,
  {
   {43  ,   0  ,   0 ,    0},
   {44  ,  0   ,  1  ,   1}
  }
  ,
  {
   {45 ,    0  ,   0  ,   1},
   {46  ,   0  ,   1  ,   0} 
  }
  ,
  { 
   {47   ,  0 ,    1  ,   1 },
   {48   ,  0  ,   0  ,   0 } 
  }
  ,
  {
   { 49  ,   0  ,   0  ,   1 },
   { 50  ,   0   ,  1   ,  0 }
  }
  ,
  { 
   {51   ,  0    , 1 ,    1 },
   {52   ,  0   , 0  ,  0} 
  }
  ,
  { 
   {53  ,   0,     1  ,   0 },
   {54   ,  0 ,   0  ,  1} 
  }
  ,
  { 
   {55  ,   0   ,  0   ,  0 },
   {56  ,   0   ,  1  ,   1} 
  }
  ,
  { 
   {57  ,   0  ,   1  ,   0},
   {58  ,   0  ,   0  ,   1} 
  }
  ,
  { 
   {59   ,  0   ,  0 ,    0 },
   {60   ,  0   ,  1  ,   1} 
  }
  ,
  { 
   {61 ,    0 ,    0  ,   1 },
   {62   ,  0  ,   1  ,   0}
  }
  ,
  { 
   {63   ,  0  ,   1 ,   1},
   {64  ,  0  ,   0 ,   0 } 
  }
  };

修复您的代码

这段代码就在这里

public class GlobalMember
    {
     int[] revealed =[1 0];
     int[] tmp= {0,0};
   for(int j=0 ; j<64 ; j++)  
     { for (int m = 0 ; l < 2 ; l++)
       {      
           tmp[l] = 
             IntStream.of((Math.abs(state[m, 3 : 4, j] - revealed))).sum();
             //note that I always just check 3rd and 4th columns values which 
            //they are implicitly an array with two element at every row of 
           //the two rows at every j(j is range from 0 to 64).
       }
     }
    }

你会不会看到java中的每个程序都以一个类和一个主方法开头，所以你所做的一切都需要封装在一个方法中，该方法在一个类内部你可以阅读这个简单的tutorial

让我们把它放在一个方法中，如果我不理解你的逻辑，请原谅我，但基本上如果你试图找到所有元素的总和，你必须声明一个变量来存储结果并不断添加它以获得你的结果。当我们这样做的时候，让我们在这个类中声明你的 main 方法

public class FindSum
{
 public static void main(String[] args)
 {
  int[][][] state=//The array i showed above cause i can't be asked to paste that here again

  System.out.println(findSum(state)); //You call that function here
 }

 public static int findSum(int[][][] state)
 {
  int sum=0;

  //Using the same logic from above

   for(int layer2D=0;layer2D<state.length;layer2D++)  //Iterate over every 2D array layer in this 3D array
   {
     for(int layer1D=0;layer1D<state[layer2D].length;layer1D++)  //iterate over every 1D layer of this current 2D array
     {
      for(int element=0;element<state[layer2D][layer1D].length;element++) //finally iterate over every element of this current 1D layer or 1D array
      {
       int value=state[layer2D][layer1D][element];
        
       sum+=value;
      }
     }
   }
   return sum;
 }
}

我在这里只介绍了基础知识，所以找到一些好的教程，那里有很多。

【讨论】：

非常感谢，但您误解了我，所以请多多包涵，因为我在这个问题上苦苦挣扎了大约两周。我只想为数组的每一行添加第三列和第四列的两个元素（数组的每个四个值我取最后两个值，数组中有 64 行）。例如，对于第一行，数组的第 3 列和第 4 列的值为 [0 0] ，对于第二行，第 3 列和第 4 列的值为 [1 1] ；所以我只需要返回每行列的第三个和第四个值的总和。
那么你的问题就变得更简单了，因为你不需要一个 3d 数组而只需要一个 2d 数组。二维数组的内部循环（我已经在上面展示了如何迭代）只需要从 2->3[第 3 和第 4 列开始循环，因为数组索引从 0->n-1] 开始，然后使用相同的求和逻辑我已经在上面展示了。