Урок J-12. Многомерные массивы в Java.

10 августа 2014

Мария (admin)

В уроке 10 мы научились создавать одномерные массивы. Подобным образом в Java можно создать двумерный, трехмерный, четырехмерный… иначе говоря, многомерные массивы. Многомерный массив в Java по сути является массивом из массивов.

Популярным примером использования такого рода массивов, являются матрицы, для представления которых, используются двумерные массивы. Итак, что же такое матрица и как ее представить с помощью двумерного массива в Java.

Матрицы и двумерные массивы в Java

Матрица это прямоугольная таблица, состоящая из строк и столбцов на пересечении которых находятся её элементы. Количество строк и столбцов матрицы задают ее размер.

Общий вид матрицы размером m x n ( m — количество строк, n — количество столбцов), выглядит следующим образом:

Каждый элемент матрицы имеет свой индекс, где первая цифра обозначает номер строки на которой находится элемент, а вторая — номер столбца.

Рассмотрим примеры конкретных матриц и создадим их с помощью Java.

Матрица A имеет размерность 2 на 3 (2 строки, 3 столбца). Создадим двухмерный массив этой размерности:

int[][] matrixA;
matrixA = new int[2][3];

Мы объявили двумерный массив целых чисел (поскольку матрица в данном случае содержит целые числа) и зарезервировали для него память. Для этого мы использовали 2 индекса: первый индекс определяет строку и ее размер, второй индекс определяет столбец и его размер.

Далее будем инициализировать массив поэлементно. Запишем матрицу A в виде таблицы, чтобы было визуально понятно, какому индексу соответствует элемент.

Для доступа к элементам двумерного массива необходимо использовать 2 индекса: первый для строки, второй – для столбца. Как и в случае с одномерными массивами, индексы также начинаются с нуля. Поэтому нумерация строк и столбцов в таблице начинается с 0.

matrixA[0][0] = 1;
matrixA[0][1] = -2;
matrixA[0][2] = 3;
matrixA[1][0] = 4;
matrixA[1][1] = 1;
matrixA[1][2] = 7;

Для того, чтобы вывести матрицу на консоль, нужно пройти все элементы, используя два цикла. Количество циклов, при прохождении элементов массива, равно его размерности. В нашем случае первый цикл осуществляется по строкам, второй — по столбцам.

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.print(matrixA[i][j] + "\t");
    }
    System.out.println();
}

То есть, сначала выводим все элементы первой строки, отделяя их символом табуляции "\t", переносим строку и выводим все элементы второй строки.

Полностью код для матрицы А выглядит следующим образом:

public class Matrix {

        public static void main(String[] args) {

                int[][] matrixA;
                matrixA = new int[2][3];
                
                matrixA[0][0] = 1;
                matrixA[0][1] = -2;
                matrixA[0][2] = 3;
                matrixA[1][0] = 4;
                matrixA[1][1] = 1;
                matrixA[1][2] = 7;              

                for (int i = 0; i < 2; i++) {
                    for (int j = 0; j < 3; j++) {
                        System.out.print(matrixA[i][j] + "\t");
                    }
                    System.out.println();
                }
        }
}

Для матрицы B воспользуемся упрощенным способом инициализации — в момент объявления. По аналогии с одномерными массивами.

int[][] matrixB = {
        {-9,1,0},
        {4,1,1},
        {-2,2,-1}
};

Каждую строку массива необходимо заключить в пару фигурных скобок и отделить друг от друга запятой.

Полностью код для матрицы B:

public class Matrix {

        public static void main(String[] args) {

                int[][] matrixB = {
                        {-9,1,0},
                        {4,1,1},
                        {-2,2,-1}
                };              

                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {
                        System.out.print(matrixB[i][j] + "\t");
                    }
                    System.out.println();
                }
        }
}

Рассмотрим инициализацию в цикле для двумерного массива на примере таблицы умножения.

public class Mult {

        public static void main(String[] args) {
                // создаем двумерный массив 10 на 10
                int[][] multiplyTab  = new int[10][10];
                
                // цикл по первой размерности
                for (int i = 0; i < 10; i++) {
                    // цикл по второй размерности
                    for (int j = 0; j < 10; j++) {
                        //инициализация элементов массива
                        multiplyTab[i][j] = (i+1)*(j+1); 

                        //вывод элементов массива 
                        System.out.print(multiplyTab[i][j] + "\t");
                    }
                    System.out.println();
                }
        }
}

Здесь инициализация элементов значениями таблицы умножения совмещена с их выводом на консоль в одном цикле.

Многомерные и несимметричные массивы.

Создаются многомерные массивы в Java аналогичным способом. Количество квадратных скобок указывает на размерность.
Примеры создания массивов фиксированной длины:

int[][] a = new int[5][5];// двумерный массив
int[][][] b = new int[3][4][5];// трехмерный массив
int[][][][] c = new int[2][4][5][5];// четырехмерный массив
// и т.д.

Однако, не обязательно изначально указывать размер на всех уровнях, можно указать размер только на первом уровне.

int[][] a1 = new int[5][];// двумерный массив с 5 строками

В данном случае, пока неизвестно сколько будет элементов в каждой строке, это можно определить позже, причем, массив может содержать в каждой строке разное количество элементов, то есть быть несимметричным. Определим количество элементов в каждой строке для массива a1

a1[0] = new int [1];
a1[1] = new int [2];
a1[2] = new int [3];
a1[3] = new int [4];
a1[4] = new int [5];

В результате, при выводе на экран,

for(int i = 0; i<a1.length; i++){
        for(int j = 0; j<a1[i].length; j++){                 
            System.out.print(a1[i][j] + " ");
        }
        System.out.println();
}

массив будет иметь такой вид:

0
0 0
0 0 0
0 0 0 0
0 0 0 0 0

При создании массива его элементы автоматически инициализируются нулями, поэтому в это примере на экран выведены нули.

Упражнения на тему многомерные массивы в Java:

Создайте массив размерностью 5 на 6 и заполните его случайными числами (в диапазоне от 0 до 99 ). Выведите на консоль третью строку
Даны матрицы С и D размерностью 3 на 3 и заполненные случайными числами в диапазоне от 0 до 99. Выполните по отдельности сначала сложение, потом умножения матриц друг на друга. Выведете исходные матрицы и результат вычислений на консоль.
Просуммируйте все элементы двумерного массива.
Дан двумерный массив, содержащий отрицательные и положительные числа. Выведете на экран номера тех ячеек массива, которые содержат отрицательные числа.
Отсортируйте элементы в строках двумерного массива по возрастанию

Категория: Уроки Java

Комментарии и пинги к записи запрещены.

Комментариев к записи: 13

Наталья:

Август 14, 2014 в 10:28 дп

Большое спасибо за новый урок! Долго ждали!
Сергей:

Август 14, 2014 в 3:57 пп

Мария, здравствуйте.
С программированием немного знаком (Pascal, C#). Решил изучить java. В интернете примеров тьма. Случайно попал на study-java и не жалею. Отличное изложение материала и проект в целом! Продолжайте в том же духе!

Мои варианты решения упражнений:
1 — http://pastebin.com/zLyVLWD0
2 — http://pastebin.com/skwwsU1p
3 — http://pastebin.com/NybmgsVq
4 — http://pastebin.com/RSiJMawN
5 — http://pastebin.com/CFNhST1j

Работает все правильно. Поэтому жду подсказок по реализации (упрощению).
- Мария (admin):
  
  Август 14, 2014 в 6:13 пп
  
  Добрый день, Сергей, спасибо за комментарий. Код хорошо оформлен, видно, что есть опыт в программировании. 2 момента:
  4. В 4 задании имелось ввиду, что массив содержит и отрицательные и положительные числа, а не только отрицательные, и надо выписать только те ячейки, которые содержат отрицательные числа. Исправлю формулировку.
  5. Для того, чтобы отсортировать элементы в строках двумерного массива достаточно написать
  for (int i = 0; i < matrixSort.length; i++) Arrays.sort(matrixSort[i]);
  - Сергей:
    
    Август 14, 2014 в 7:41 пп
    
    Спасибо за пояснения. При выполнении 5 задания как раз возник такой вопрос.
    4 задание переделал — http://pastebin.com/1H2syBbC
    Добавьте в формулировку — двухмерный.
    - Мария (admin):
      
      Август 14, 2014 в 11:48 пп
      
      Добавила. Еще при прохождении массива, в двойном цикле лучше использовать length для определения количества строк в массиве и их длинны. Это будет выглядеть так:
      
      for (int i = 0; i < matrixMinus.length; i++) { for (int j = 0; j < matrixMinus[i].length; j++){ matrixMinus.length определяет количество строк в массиве matrixMinus, matrixMinus[i].length - определяет количество элементов в определенной строке. Используя такую запись, вы можете менять размерность массива, при этом вам не придется во всех циклах менять цыфры. Позже добавлю эту информацию в урок.
Владислав:

Август 19, 2014 в 11:12 дп

Добрый день! Мне очень нравятся вши уроки! Жаль, что редко выходят. Когда будут следующие уроки? Спасибо!
- Мария (admin):
  
  Август 19, 2014 в 11:17 дп
  
  Добрый день, уроки выкладываются по мере написания. Следующий планирую на этой неделе.
Владислав:

Август 22, 2014 в 9:58 дп

Добрый день! Сортировка Arrays.sort не работает для многомерных массивов?
- Мария (admin):
  
  Август 22, 2014 в 2:43 пп
  
  Добрый день, работает, если вы хотите отсортировать, например, строку в многомерном массиве. Смотрите комментарий выше, я там приводила пример.
Сабина:

Август 27, 2014 в 10:04 дп

Добрый день!
Мария,если я не ошибаюсь, то перемножение массивов происходит по более сложной схеме, а не просто перемножить идентичные элементы матрицы.
Вот мой пример второго задания.
http://pastebin.com/CQ68VuCX
- Мария (admin):
  
  Август 27, 2014 в 11:24 дп
  
  Добрый день, да матрица умножается строка на столбец (но не все это знают). У вас все верно, но можно немного упростить, не использовать временую переменную http://pastebin.com/sCvYr9vj