Как отобразить сумму элементов myArray, используя вложенные улучшенные циклы for?

Question

Я создал программу для назначения, которая требует от меня отображения элементов массива с использованием вложенных улучшенных циклов for.

Я получаю сообщение об ошибке, что он не может преобразовать тип элемента Integer [] в тип int.

myArray уже был создан и правильно инициализирован в конструкторе. Я знаю, что это правильно, потому что я могу отображать элементы массива в формате списка просто отлично, от 1 до 60.

public void displayArrayProduct() {

    DecimalFormat decimalFormat = new DecimalFormat("#.##");
    decimalFormat.setGroupingUsed(true);
    decimalFormat.setGroupingSize(3);

    int p=1;

    System.out.print("The product of all element of myArray is ");
    for (int a : myArray) {
        for (int b : myArray) {
             p = p + myArray[a][b];

        }
    }
    System.out.println(decimalFormat.format(p));
}

}

Я ожидал, что это будет выводить сумму всех элементов массива. Я попробовал ту же самую вещь с обычными для циклов, и это работало отлично. К сожалению, когда я переключился на расширенный цикл for, он перестал работать, выдав мне ошибку:

Несоответствие типов: невозможно преобразовать тип элемента Integer [] в int

Вот так выглядит мой конструктор:

ExerciseTwo () {

    myArray = new Integer[6][10];

    for (int i = 0; i < myArray.length; i++) {
        for (int j = 0; j < myArray[i].length; j++) {
            this.myArray[i][j] = i + 1;

        }
    }
}

Answer 1

Вы упомянули, что в вашем массиве 60 элементов, поэтому я просто создал образец массива 2 x 30 в качестве примера:

int[][] myArray = new int[2][30];
    int increment = 0;
    for(int x = 0; x < myArray.length; x++) {
        for(int y = 0; y < myArray[x].length; y++) {
            myArray[x][y] = increment;
            increment++;
        }
    }

Далее, если вы используете цикл for-each, ваша ошибка возникает из-за того, что каждая отдельная строка массива является ИНДЕКСОМ В ЕГО СЕБЕ. Таким образом, ваш цикл for-each должен иметь тип (int []) int Array:

for(int[] x: myArray) {

Внутри каждого отдельного массива (x) есть примитивное значение типа int, поэтому мы запускаем еще один цикл for-each для извлечения каждого отдельного значения:

для (int y: x) {

А вот ваш полный код:

for(int[] x: myArray) {
        for(int y: x) {
            totalVal += y;
        }
    }
System.out.println(totalVal);

И результат - сумма каждого целого в массиве:

1770

Answer 2

Похоже, что myArray - это массив массивов, а не массив целых чисел. Может быть, это больше, что вам нужно?

    for (int[] a: myArray) {
        for (int b: a) {
            p = p + b;
        }
    }

Answer 3

for (int[] a : myArray) {
    for (int b : a) {
         p = p + b;

    }
}

Ну, проблема в том, что это массив int, а не просто int.

Answer 4

Вы используете циклы for-each , которые проходят через каждый элемент в массиве или коллекции. Таким образом, вы определяете в объявлении цикла элемент из массива, а не index . Поскольку вы используете двумерный массив (массив массивов), каждый элемент в myArray представляет собой целое число массив , поэтому первый цикл должен быть объявлен:

for (int[] a : myArray) {

Таким образом, каждое значение a будет иметь тип int [], и далее вам нужно получить каждое целое число из каждого из этих целочисленных массивов:

for (int b : a) {

Обратите внимание, что вы получаете каждое целое число в a, а не в myArray. Теперь вы можете ссылаться на каждое целое число в массиве как на b, а не на значение массива по индексу b:

p = p + b;

Answer 5

Обновление: мой оригинальный ответ был опубликован до того, как стало ясно, что myArray - это многомерный массив. Учитывая это, я согласен с Вечной, которая также правильно указала, что использование цикла for-each позволит вам получить целое число вместо ссылки на него по индексу.

Оригинальный ответ: Похоже, вы изменили что-то еще, когда преобразовали циклы for.

Выражение myArray [a] [b] было бы допустимым, если бы myArray был многомерным массивом. Проблема в том, что вы пытаетесь получить доступ к двумерному массиву, когда сам массив является одномерным.

Если вы пытаетесь умножить записи на a и b, вам нужно сделать это:

p = p + myArray[a] * myArray[b];

или сокращенно:

p += myArray[a] * myArray[b];