java中多个int[]]数组到单个[]字符串数组

所以，我是编程新手，我有一个练习，我必须阅读一个

int[][]

数组，其中有年龄和残疾水平的人试图成为俱乐部的会员，有两个类别，高级和开放。 我的工作是读取

示例[[45,12]，[55,21]，[19，-2]]

的数组，其中第一个int表示年龄，第二个int表示残疾水平。如果年龄至少为

55

，且残疾水平高于

7

，则该人将获得高级会员资格，如果不是，则他将获得开放会员资格。我的想法是将

int[][]

视为一个矩阵，并添加两个数字（年龄和级别），如果数字高于62，我会将其归类为高级，否则将其归类为开放。 我的方法如下所示：

public class montecarlo {
    static String[] openOrSenior(int[][] a) {
        int i, j, sum;
        String[] abo = new String[a[0].length];
        for (i = 0; i < a.length; i++)
            for (j = 0; j < a[0].length; j++ ) {
                sum = 0;
                int x = a[i][j];
                sum = sum + x;
                if (sum > 62)
                   abo[i] = "Senior";
                else 
                   abo[i] = "Open"; //this would be line 12
            }   
        return abo;
}

    public static void main(String[] args) {
        int [][] a = {{42, 12},{55, 21},{19,-2}};
        String[] x = openOrSenior(a);    //this would be line 20
        Out.print(x);    //here was to see what i'd get if i let it run

    }
}

公共级蒙特卡洛{
静态字符串[]openOrSenior（int[]a）{
int i，j，和；
字符串[]abo=新字符串[a[0]。长度]；
对于（i=0；i62）
abo[i]=“高级”；
其他的
abo[i]=“打开”；//这将是第12行
}   
返回abo；
}
公共静态void main（字符串[]args）{
int[]a={{42,12}，{55,21}，{19，-2}；
字符串[]x=openOrSenior（a）；//这将是第20行
Out.print（x）；//这里是想看看如果让它运行，我会得到什么
}
}

这是我得到的错误：

线程“main”java.lang.ArrayIndexOutOfBoundsException中出现异常异常：2 openOrSenior（montecarlo.java:12）在 main（montecarlo.java:20）

我真的很感谢你的帮助。

试试类似的方法

public class montecarlo {
public static void main(String[] args) {
        int [][] a = {{42, 12},{55, 21},{19,-2}};
        String[] x = openOrSenior(a);    //this would be line 20
        System.out.println(Arrays.asList(x));    //here was to see what i'd get if i let it run

    }

    static String[] openOrSenior(int[][] a) {
        int i, j, sum;
        String[] abo = new String[a.length];
        System.out.println(abo.length);
        for (i = 0; i < a.length; i++)
            for (j = 0; j < a[0].length; j++) {
                sum = 0;
                int x = a[i][j];
                sum = sum + x;
                if (sum > 62)
                    abo[i] = "Senior";
                else abo[i] = "Open";
            }   //this would be line 12
        return abo;
    }
}

公共级蒙特卡洛{
公共静态void main（字符串[]args）{
int[]a={{42,12}，{55,21}，{19，-2}；
字符串[]x=openOrSenior（a）；//这将是第20行
System.out.println（Arrays.asList（x））；//这里是为了看看如果让它运行会得到什么
}
静态字符串[]openOrSenior（int[]a）{
int i，j，和；
String[]abo=新字符串[a.length]；
系统输出打印长度（abo.长度）；
对于（i=0；i62）
abo[i]=“高级”；
else abo[i]=“打开”；
}//这是第12行
返回abo；
}
}

这修复了所有数组边界问题，但正如其他人所提到的，不是语义上的缺陷。完全重写这个答案是没有意义的，所以我保留原样

我注意到您的代码中有两个主要问题可能导致上述异常

在第12行，您的问题是，您定义的数组大小错误

String[] abo = new String[a.length];

但还有一个类似的问题，因为第二个周期的长度不正确，您需要：

for (j = 0; j < a[i].length; j++ )

（j=0；j 好的，这个问题永远不会发生，因为所有数组的长度都相同。但是如果有一个没有残疾的人和一个有残疾的人在一起，它就会在循环中崩溃

下一个练习-创建一个新类，该类包含两个

int

变量，

age

和

disability

。在Java中就是这样做的。整数数组对年龄和残疾没有区别。

import java.util.*；
import java.util. * ;
import java.lang. * ;
import java.io. * ;

class montecarlo {
    static String[] openOrSenior(int[][] a) {
        int i,
        j,
        sum,
        x;
        /*Declare x here, otherwise in your code it will create a new variable everytime in your for loop*/
        String[] abo = new String[a.length];
        /* a.length not a[0].length */

        for (i = 0; i < a.length; i++) {
            sum = 0;
            /* sum should initialised to zero here every time outside the inner for loop*/

            for (j = 0; j < a[0].length; j++) {

                x = a[i][j];
                sum = sum + x;

            }
            /* check outside for loop whether the total sum is greater than 62 */

            if (sum > 62) {
                abo[i] = "Senior";

            }
            else {
                abo[i] = "Open";

            }

        }
        return abo;

    }

    public static void main(String[] args) {
        int[][] a = {
            {
                42,
                12
            },
            {
                55,
                21
            },
            {
                19,
                -2
            },
            {
                72,
                74
            }
        };
        String[] x = openOrSenior(a);
        System.out.print(x);

    }

}

导入java.lang.*；
导入java.io.*；
蒙特卡洛级{
静态字符串[]openOrSenior（int[]a）{
int i，
J
总和
x；
/*在这里声明x，否则在代码中它将在for循环中每次创建一个新变量*/
String[]abo=新字符串[a.length]；
/*a.length不是[0]。length*/
对于（i=0；i62）{
abo[i]=“高级”；
}
否则{
abo[i]=“开放”；
}
}
返回abo；
}
公共静态void main（字符串[]args）{
int[]a={
{
42,
12
},
{
55,
21
},
{
19,
-2
},
{
72,
74
}
};
字符串[]x=打开或关闭（a）；
系统输出打印（x）；
}
}

这是你想要的工作演示。 我已经在评论中指出了您的错误。 您已经犯了几个错误，请仔细阅读代码并理解您的错误

您的逻辑中也有一个缺陷，您应该自己修复。 例如，年龄=60岁，残疾级别=3

---

total=60+3=63，大于62，因此根据您的逻辑应为“高级”，但这是错误的，因为障碍级别低于7。

这里有一个更简单的版本，语法错误已修复

public class montecarlo {
    static String[] openOrSenior(int[][] a) {
        String[] abo = new String[a.length]; // you had a[0] here instead of a
        for (int i = 0; i < a.length; i++) {
            if (a[i][0] >= 55 && a[i][1] > 7) {
                abo[i] = "Senior";
            } else {
                abo[i] = "Open";
            }
        }
        return abo;
    }
}

公共级蒙特卡洛{
静态字符串[]openOrSenior（int[]a）{
String[]abo=新字符串[a.length]；//此处有一个[0]而不是一个
for（int i=0；i=55&&a[i][1]>7）{
abo[i]=“高级”；
}否则{
abo[i]=“开放”；
}
}
返回abo；
}
}

其实很简单<（j=0；j噢，又一个错误<代码>字符串[]abo=新建