java(内置方法)实现中的求和？

zfciruhq 于 2021-06-27 发布在 Java

关注(0)|答案(2)|浏览(281)

大家好，新年快乐。
我来自matlab世界，不到一年就开始用java编写代码。我在解决这个问题，这可能很容易，但请容忍我！以下是matlab的代码：state是3d数组的一个变量，其大小为2x4x64。状态值是：（这是我在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，state（l，3:4，j）根据j给出两列值，然后我们减去显示的数组，然后做abs，然后求和到数组结果。例如：state（m，3:4，1）。对于m=1，j=1给出了[0 0]和[1 1]，第三列和第四列的m=2。所以在每m处，我从第三列和第四列的两个值中减去[10]。所以在m=1时，我们有[0]，所以[0]——显露=>[0]，[1 0]=>[-1 0]，我们做abs（[-1 0]），得到[1 0]，然后我们求和，它是1+0=>1。当m=1时，我们得到[11]，所以[11]-[10]=>[10]我们在这个数组上做abs=>[10]，然后我们做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).
       }
     }
    }

但听起来我遗漏了一些东西，它根本不编译，谁能帮我如何实现这个代码matlab在java中？我的意思是在java中实现与matlab代码相同的概念。
我挣扎了大约一个星期，我不明白到底是哪里的问题。
多谢了。

Java Arrays ArrayList Collections matlab

来源：https://stackoverflow.com/questions/65575448/sum-in-java-built-in-methods-implementation

2条答案

按热度按时间

eit6fx6z1#

您必须修复初始化sintax（逗号分隔的值），这里要求使用类似的语法来创建二维数组
我想你应该这样做：

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

赞(0）回复(0）举报 2021-06-27

whhtz7ly2#

首先让我们熟悉基本知识。让我们从二维数组开始。
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数组。层的数量是行，每层中每个1d数组的长度是列。
要遍历每个元素，您可以这样做

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）三维阵列
现在，正如二维数组包含多层一维数组一样，三维数组也包含多层二维数组，让我们看一个示例

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];

还有一个限制，即每个2d数组层必须以网格方式初始化
事实上，你可以从这个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）修复阵列
由于您正在使用方法1初始化三维阵列，因此不需要指定长度。这是你最后的阵法

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中的每一个程序都是从一个类和一个主方法开始的，所以你所做的一切都需要封装在一个方法中，这个方法在一个类的内部，你可以阅读这个简单的教程
让我们把它放在一个方法中，如果我不理解你的逻辑，请原谅，但基本上如果你试图找到所有元素的总和，你必须声明一个变量来存储结果，并不断添加到它来得到你的结果。当我们在这里的时候，让我们在这个类中声明你的主方法

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;
 }
}

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

赞(0）回复(0）举报 2021-06-27

我来回答

java(内置方法)实现中的求和？

2条答案

相关问题

热门标签

最新问答