Содержание

Java для начинающих | Урок 13: Многомерные массивы.

  • Главная >
  • Видео канал >
  • Java для начинающих | Урок 13: Многомерные массивы.

УЛУЧШАЙТЕ НАВЫКИ С ПОМОЩЬЮ ПРАКТИКУМА

СЛЕДУЮЩЕЕ

В этом уроке, рассматривается тема — «Java для начинающих. Многомерные массивы». Понятие многомерного массива. Работа с использованием многомерными массивами. Смотрите новые видео на видеоканале ITVDN и получайте еще больше знаний и навыков.

Please enable JavaScript to view the comments powered by Disqus.

Регистрация через

✖

или E-mail

Нажав на кнопку «Зарегистрироваться»,
Вы соглашаетесь с условиями использования.

Уже есть аккаунт

Получите курс бесплатно

✖

Вы выбрали курс для изучения
«»
Чтобы получить доступ к курсу, зарегистрируйтесь на сайте.

РЕГИСТРАЦИЯ

Спасибо за регистрацию

✖

Перейдите на почту и подтвердите Ваш аккаунт,
чтобы получить доступ ко всем
бесплатным урокам и вебинарам на сайте ITVDN. com

ПОДТВЕРДИТЬ ПОЧТУ НАЧАТЬ ОБУЧЕНИЕ

Спасибо за регистрацию

✖

Ваш аккаунт успешно подтвержден.
Начать обучение вы можете через Личный кабинет
пользователя или непосредственно на странице курса.

НАЧАТЬ ОБУЧЕНИЕ

Подтверждение аккаунта

На Ваш номер телефона было отправлено смс с кодом активации аккаунта. Пожалуйста, введите код в поле ввода.

Отправить код еще раз

Изменить номер телефона

Ошибка

✖

Многомерные массивы в Java, Java для начинающих

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

В этом примере мы объявляем два целочисленных массива — a и b.

Первый массив a заполняем при объявлении конкретными значениями. Второй массив двумерный. Для его заполнения используем два цикла с параметром, в которых умножаются переменные i и j.

Поиск максимального элемента массива

Давайте повторим, что такое массив

Массив


#

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

многомерный массив на примере февраля

monthCalendar
monthCalendar 47

outer 0 outer monthCalendar outer
inner 0 inner monthCalendarouter inner
monthCalendarouterinner outer7 inner 1
SystemmonthCalendarouterinner

System monthCalendar13

Я создал массив с четырьмя строчками и семью столбиками. Создал два фор цикла для инициализации массива. Во внешнем цикле я обхожу столбики, во внутреннем цикле я обхожу строчки. В программировании отсчёт начинается с нуля, а не с единицы и формула инициализации дней февраля равна порядковый номер строчки умноженный на семь плюс порядковый номер столбика.

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

Двумерный массив


#

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

String myArray String53

myArray00
myArray01
myArray02

myArray10
myArray11
myArray12

myArray20
myArray21
myArray22

myArray30
myArray31
myArray32

myArray30
myArray31
myArray32

Трёхмерный массив фиксированной длины:

a1 102030

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


#

byteArray

0 1 2
1 2 3
3 4 5

1 2 3
2 3 4
5 6 7

a1 5// двумерный массив с 5 строкамиa10 1
a11 2
a12 3
a13 4
a14 5

array a1
element array
Systemelement

System

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

example
1
2 2
3 3 3
4 4 4 4
5 5 5 5 5

Класс java. util. Arrays содержит методы для работы с массивами.

  • copyOf() − предназначен для копирования массива
  • copyOfRange() − копирует часть массива
  • toString() − позволяет получить все элементы в виде одной строки
  • fill() − заполняет массив переданным значением (удобно использовать, если нам необходимо значение по умолчанию для массива)
  • equals() − проверяет на идентичность массивы
  • deepEquals() − проверяет на идентичность массивы массивов

arr 2 2 1 8 3 2 2 4 2
// To fill complete array with a particular valueArraysarr 10
System»Array completely filled with 10
» Arraysarr
System Arraysarr

Домашнее задание


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

Дополнительные материалы


#

В Java многомерные массивы представляют собой массивы массивов.

При объявлении переменной многомерного массива для указания каждого дополнительного индекса используют отдельный набор квадратных скобок. Например, следующий код объявляет переменную двумерного массива twoD.

Этот оператор распределяет память для массива размерностью 4×5 и присваивает ссылку на  него переменной twoD. Внутренне эта матрица реализована как массив массивов значений типа int. С точки зрения логической организации этот массив будет выглядеть так:

Это мы рассмотрели логическую организацию двумерного массива. Физическая же, или то, как распределяется память под массив несколько другая. Поэтому, прежде чем приступить к работе с многомерными массивами, нужно понять несколько дополнительных деталей.

Допустим, вы хотите представить таблицу умножения в виде многомерного массива:

Новый многомерный массив создается при помощи ключевого слова new с указанием размеров обоих измерений массива. Например:

В некоторых языках такой массив создается в виде единого блока из 100 значений int. Java поступает иначе. Эта строка кода выполняет три действия:

  • Объявляет переменную с именем multiplicationTable, которая содержит ссылку на массив ссылок, которые в свою очередь будут указывать на массивы int.
  • Создает массив из 10 элементов (первый индекс), который будет содержать ссылки на 10 одномерных массивов int. Вот от сюда собственно и понятие – массив массивов.На этой стадии создания массив ссылок заполняется значениями по умолчанию, то есть значениями null.
  • Создает еще 10 массивов, каждый из которых в свою очередь является массивом из 10 элементов int. Присваивает ссылки на каждый из этих 10 новых массивов элементам массива, созданного на втором шаге. По умолчанию каждый элемент int каждого из этих 10 новых массивов получает значение 0.

Другими словами, представленную выше строку кода, можно записать так:

Графически это можно изобразить так:

Очень важно понять, что каждый из массивов с элементами int, располагаются в памяти непрерывным куском, но где и как расположены каждый из них это определяет виртуальная машина java. Исходя из этого есть рекомендация, что наружные (левые) размерности массива лучше делать меньше, а самые больше размерности внутри (правее), поскольку это, во-первых, уменьшит фрагментацию памяти, а во вторых потребует гораздо меньше памяти для размещения массива. Возьмем к примеру вот такие два определения двумерных массивов:

В случае массива a, количество порождаемых в памяти объектов равно 11, а в случае массива b – 1001. Создание и обслуживание каждого объекта в памяти виртуальной машины имеет свои накладные расходы, так как виртуальная машина считает ссылки для каждого объекта, хранит его атрибуты и т. и т. Таким образом массив b может занимать в памяти в полтора, а то и в два раза больше места чем массив a.

Чтобы все еще стало понятней, лучше немного попрактиковаться

Данная программа генерирует следующий вывод:

По существу шаги 1 и 2 выполняются в 9 строке программы.

Строки 12-15 лишь выводят значения элементов первого индекса массива, где содержаться указатели на массивы значений int. Но на данный момент там еще значения null, так как им еще не были присвоены ссылки на массивы со значениями int.

После создания массивов int (строки 18-21), на третьем шаге мы видим что теперь в первом индексе, то есть в массиве содержащем ссылки на массивы int уже находятся ссылки на эти массивы.

И теперь если обратиться по обоим индексам массива multiplicationTable, то мы увидим что массивы int были заполнены значениями по умолчанию для данного типа, то есть нулями.

Ключевое слово new автоматически выполняет инициализацию элементов массива значениями по умолчанию.

Ну и затем мы просто присвоили значения каждому элементу массива, которое соответствует результату умножения индексов данного элемента и выводим их на консоль. Это можно сделать и более красиво отформатировав вывод, но это мы пока еще не изучали, поэтому вернемся к этому вопросу чуть позже.

При работе с многомерными массивами в Java очень важно понять, что первые индексы многомерных массивов содержат только массивы ссылок, и только последний (самый правый) индекс содержит непосредственно элемент данных типа объявленного для массива.

То есть в Java можно объявить и более чем двумерные массивы. Например:

И тут очень важно понимать, что первый индекс данного массива, содержит массив ссылок, на второй индекс данного массива, который в свою очередь тоже содержит массив ссылок на массивы значений int.

Если так же рассмотреть предыдущий пример, то код приведенный ниже вызовет ошибку компиляции:

В тоже время нижеприведенный код не вызовет ошибки компиляции, но вызовет ошибку во время исполнения: NullPointerException.

Это происходит потому, что не был создан объект, в данном случае массив int-ов. То есть мы создали массив хранящий ссылки, на массивы int-ов, но сами эти массивы мы еще не создали, поэтому обращение к несуществующему объекту вызывает данную ошибку. Строка 19 из предыдущего примера, как раз показывает пример правильного создания объектов (массивов), на которые ссылается первый индекс. Ключевое слово new, так же служит и для создания и инициализации вложенных массивов.

В последнем примере, мы создали массив ссылок, но не создали массив int-ов, поэтому к нему и не возможно обратиться. Это можно исправить следующим кодом:

Все правила создания массивов, которые мы рассматривали ранее, справедливы и для много мерных массивов, то есть должны присутствовать все стадии: объявление, создание и инициализация.

Как уже упоминалось в Java можно создавать массивы любой размерности:

Если вы создаете многомерные массивы, вам необязательно указывать все измерения массива – важно задать только крайнее слева измерение или измерения. Например, разрешены такие строки:

Но такие варианты ошибочны:

Еще раз напомню, что очень важно понять, что первые индексы (измерения) массивов содержат только ссылки, и не могут содержать объекты объявленного для массива типа, их содержит только крайнее левое измерение (индекс).

Напомню, что такой синтаксис инициализации, можно использовать только при объявлении массива или при использовании анонимного массива, то есть массива без имени:

Поскольку в Java многомерные массивы реализуются как массивы массивов,  вы можете использовать не только прямоугольные массвы. Например:

Приведу еще одни пример небольшой магии с массивами в Java, чтобы углубить понимание данной темы.

В строке 9 мы создаем и инициализируем одномерный массив. В 11 строке создаем двумерный массив. В 12 строке происходит магия. Если вы внимательно читали, все что было написано до сих пор то должны разобраться что произошло.

Поскольку, как я уже говорил, первые индексы многомерных массивов содержат ссылки на массивы, то в данном случае мы туда присвоили ссылку на одномерный массив oneD.

А пока добавлю еще немножко магии к предыдущей программе

Тут я добавил в строках 20 и 21 поясняющий вывод, что же сталось с массивами и как они выглядят после операции в строке 17.

Кроме этого были добавлены строки создания массива int-ов, для второго индекса массива twoD, то есть для индекса 1, а так же заполнения его значениями. Это строки 23-25.

Далее, строка 26, просто вывод массива twoD на консоль.

В 27 строке небольшая магия, мы присвоили ссылку на массив int-ов, которые только что создали в массиве twoD, массиву oneD.

Затем вывели содержимое массива oneD на консоль. И уже после этого адреса ссылок на массивы.

Цель этой программы продемонстрировать работу с массивами, и самое главное, понять разницу между объектом, в данном случае массивом, и ссылкой на объект.

Теперь наша программа генерирует следующий вывод:

А теперь поколдуем немножко с не прямоугольными массивами, дабы понять тему многомерных массивов в Java еще глубже.

Это пример работы с треугольным или ступенчатым массивом. На самом деле массивы int-ов могут быть произвольной длинны.

В 16 строке мы воспользовались стандартной библиотечным методом (Arrays. deepToString) SDK для вывода многомерных массивов на консоль, но как видно из вывода, данный метод выводит любой многомерный массив в строку, разделяя его размерности квадратными скобкам, что не очень наглядно.

Затем в цикле (строки 18-23) мы выводим треугольный массив более наглядным образом.

Следующий пример чуть интересней, будем превращать прямоугольный массив в треугольный.

В данной программе мы изначально имеем три массива: один одномерный и два двумерных, но с разным количеством элементов в строках – 2 и 3 соответственно.

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

В строках 31 и 32 мы колдуем с массивом three и затем выводим результат нашего шаманства на консоль.

В результате, как-бы, получаем честный треугольный массив.

Как-бы, это потому, что на самом деле последние два индекса ссылаются массивы two и one.

Теперь рассмотрим простенький пример трехмерного массива. Следующая программа создает трехмерный массив размерности 3×4×5. Затем она инициализирует каждый элемент произведением его индексов и выводит все это дело на консоль.

Вот такое у нас 3D

Ну и в завершение данного поста приведу программу сортировки двумерного массива пузырьком.

Первый алгоритм, это классика жанра, сортировка обычным пузырьком, второй алгоритм я написал забавы ради, что-бы показать как модифицированный алгоритм может повлиять на производительность и скорость вычислений.

Данная программа может принимать аргументы из командной строки и создавать двумерные массивы заданной размерности. Если аргументы не переданы то создается массив 10х10. Затем он заполняется случайными числами, копируется в массив который будет отсортирован первым алгоритмом, сортируется, выводится на консоль, затем несортированный снова копируется для сортировки, сортируется вторым алгоритмом и выводится на консоль.

Данная программа может сгенерировать следующие выводы:

Тут приведены примеры запусков без аргументов и с аргументами из командной строки.

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

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

Объяснять отличие работы второго алгоритма немного ленно. Постарайтесь разобраться сами.

Если не получится и если сильно интересно, пишите вопросы в комментариях, дабы мне не тратить понапрасну время на объяснения тут.

В следующем посте разберем некоторые методы работы с массивами из стандартной библиотеки.

Двумерный массив в Java

Обзор

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

Область применения статьи

  • В этой статье представлен обзор двумерных массивов в Java.
  • В статье рассматриваются все теоретические аспекты, связанные с двумерным массивом в Java, а также их реализация на языке программирования Java.
  • Общий артикул соответствует желаемому объему.

Введение в 2D-массив в Java

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

В Java это табличное представление данных реализовано с использованием двумерного массива. Двумерный массив (или 2D-массив в Java) — это линейная структура данных, которая используется для хранения данных в табличном формате.

В Java массив — это однородная коллекция фиксированного числа значений, которые хранятся в смежных ячейках памяти, т. е. элементы имеют один и тот же тип (однородные данные) и расположены в памяти линейно, так что каждый элемент связан с его предыдущим и последующим элементом.

Java рассматривает двумерный массив как массив из нескольких одномерных массивов, т. е. это набор различных одномерных массивов. Следовательно, когда мы создаем объект двумерного массива, Java создает простой одномерный массив, который ссылается (указывает на) на другие одномерные массивы, формирующие строки двумерного массива.

Следовательно, в Java двумерный массив представляет собой набор указателей, где каждый указатель ссылается на одномерный массив, представляющий конкретную строку двумерного массива.

Объявление двухмерного массива в Java

Поскольку двумерный массив состоит из строк и столбцов, нам нужны два индекса, один для ссылки на строки, а другой на конкретный столбец в этой строке. Следовательно, синтаксис объявления двумерного массива аналогичен синтаксису одномерного массива, за исключением наличия двух квадратных скобок вместо одной:

Здесь DataType описывает тип значений, которые может хранить массив, в то время как ArrayName является ссылочной переменной для объекта двумерного массива.

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

Создание двумерного массива в Java

В Java все, включая структуру данных массива, рассматривается как объекты. Следовательно, для создания объекта двумерного массива нам нужно использовать ключевое слово new, как показано ниже:

Здесь оператор new DataType[r][c] создает объект двумерного массива, который содержит r строк и c столбцов и элементов.

типа DataType. На этот объект массива ссылается ссылочная переменная ArrayName.

Давайте разберемся с созданием двумерного массива Java на примере:

Здесь ссылочная переменная a указывает на объект двумерного массива, который представляет целочисленную матрицу 3X33X33X3, т.е. объект массива содержит 333 строки и 333 столбца, и может хранить только целые (int) значения.

Примечание: Когда мы создаем объект двумерного массива с помощью нового ключевого слова, JVM (виртуальная машина Java) выделяет память, необходимую для двумерного массива, и инициализирует области памяти значениями по умолчанию в соответствии с типом данных объект массива. Например, в случае массива Integer (int[][]) каждый элемент массива инициализируется значением по умолчанию 0,9.0009

Java Двумерный массив примитивного типа

Массивы представляют собой набор элементов, имеющих схожие типы данных. Следовательно, мы можем создать массив примитивных типов данных, а также объекты. Двумерный массив примитивного типа данных в Java (скажем, int) — это просто массив массивов Integer.

Мы можем объявить двумерный массив в Java для всех примитивных типов данных Java следующим образом:

Java Two Dimensional Array of Objects

Как обсуждалось ранее, мы можем создать массив объектов. Двумерный массив объектов в Java — это просто набор массивов нескольких ссылочных переменных. Мы можем объявить двумерный массив объектов следующим образом:

Этот синтаксис объявляет двумерный массив с именем ArrayName, который может хранить объекты класса ClassName в табличной форме. Эти типы массивов, которые хранят объекты в качестве своих элементов, обычно используются при работе с объектами данных String.

Доступ к элементам двумерного массива в Java

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

В случае двумерных массивов мы используем индексы строк и столбцов для доступа к определенному элементу матрицы. Он имеет следующий синтаксис:

Здесь оператор ArrayName[i][j] используется для доступа к элементу, присутствующему на пересечении строки i th и столбца j th в двумерном массиве ArrayName. Затем этот элемент сохраняется в переменной var.

Примечание:

  • В Java индекс всегда начинается с 0. Следовательно, чтобы получить доступ к элементу в строке n th , нам нужно использовать (n-1) в качестве индекса.
  • Мы можем получить доступ только к элементам массива, используя положительное целое число в качестве индекса. Мы не можем использовать отрицательные индексы для доступа к любым элементам массива в Java.
  • Если мы передаем индекс, превышающий размер массива (индекс вне границ), возникнет ошибка ArrayIndexOutOfBoundsException.

Пример двухмерного массива Java

Теперь давайте рассмотрим пример, чтобы полностью понять двумерные массивы в Java.

Рассмотрим сценарий, в котором мы хотим сохранить оценки, полученные 3 учащимися по математике, английскому языку и естественным наукам. Здесь мы храним коллекцию оценок (оценки по английскому языку, математике и естественным наукам) для каждого ученика. Следовательно, мы можем использовать таблицу для представления и хранения оценок учащихся. В таблице «Оценки учащихся» строки будут представлять оценки конкретного учащегося, а столбцы будут представлять предмет, по которому учащийся получил эти оценки, как показано ниже:

Эта таблица оценок учащихся может быть преобразована в Java с помощью двумерных массивов. Мы можем использовать двумерный целочисленный массив для представления табличной формы оценок учащихся. Это можно реализовать следующим образом:

Код:

Вывод:

Здесь мы объявляем целочисленный массив StudentMarks, представляющий матрицу 3X3. Теперь, чтобы назначить оценки каждому ученику, мы обращаемся к соответствующим элементам, используя индексацию, а затем присваиваем оценки этому конкретному элементу.

Например, чтобы сохранить оценки, полученные учащимся 1 по английскому языку, мы обращаемся к строке 0 th (первый учащийся) и столбцу 0 th (первый предмет, т. е. английский язык), а затем заменяем целочисленное значение по умолчанию 0 с оценками студента (StudentMarks[0][0] = 90).

Наконец, мы используем встроенный метод deepToString() класса Arrays для отображения двумерного массива StudentMarks.

Способы объявления и инициализации двумерного массива в Java

В Java можно инициализировать и объявлять двумерные массивы различными способами. Давайте подробно рассмотрим каждый из этих методов инициализации:

1. Объявление двумерного массива с обоими измерениями

Чтобы объявить двумерный массив с использованием обоих измерений, нам просто нужно передать количество строк и количество столбцов матрица в квадратных скобках, как показано ниже:

Этот синтаксис объявит двумерный целочисленный массив с двумя строками и двумя столбцами.

2. Объявление двумерного массива только с одним измерением

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

Этот синтаксис объявит двумерный массив Integer, имеющий две строки и неопределенное количество столбцов, т. е. объект массива a ссылается на массив, который в дальнейшем может ссылаться на два одномерных массива.

3. Положение квадратной скобки

При объявлении двумерного массива положение квадратной скобки в операторе объявления может привести к неожиданным результатам. Давайте рассмотрим несколько примеров, чтобы понять распространенные ошибки, связанные с расположением квадратных скобок:

В приведенном выше синтаксисе мы объявляем два объекта массива a и b, где объект a представляет собой одномерный целочисленный массив, а объект b представляет двумерный целочисленный массив. Теперь

Этот синтаксис можно использовать для создания двумерных массивов в Java, поскольку int[] указывает на одномерный целочисленный массив, а a[] является самим объектом массива, тем самым объявляя целочисленный массив массивов, который, в свою очередь, двумерный массив.

4. 2D-массив с переменной длиной столбца

Поскольку Java позволяет нам объявлять 2D-массивы, предоставляя только одно измерение, мы можем объявить двумерный массив с переменной длиной столбца, используя приведенный ниже синтаксис:

Приведенный выше синтаксис: объявление двумерного целочисленного массива, имеющего 4 строки, и следующие четыре оператора назначают четыре одномерных массива, имеющих длины 1, 2, 3 и 4 соответственно, в качестве строк массива. Результат этого двумерного массива показан ниже:

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

5. Объявление и инициализация гетерогенного двумерного массива

Поскольку мы можем создать двумерный массив объектов, мы можем использовать эту функцию и встроенный в Java класс Object для создания двумерного гетерогенного массива, используя приведенные ниже -описанный синтаксис:

Этот синтаксис объявляет двумерный массив, содержащий 3 строки и столбцы переменной длины. Приведенный выше синтаксис создает двумерный массив, который выглядит следующим образом:

Здесь обратите внимание, что мы не используем примитивные типы данных, такие как int, double и char, для объявления одномерных массивов. Вместо этого мы используем их классы-оболочки : Integer, Character и Double. Это связано с тем, что двумерный массив может содержать только элементы аналогичного типа данных, которые в данном случае являются объектами встроенного класса Object.

Заключение

  • В этой статье мы рассмотрели двумерные массивы в Java и их использование.
  • Затем мы рассмотрели различные способы объявления двумерных массивов в Java.
  • Мы также видели, как Java обрабатывает двумерные массивы и как JVM выделяет память для реализации двумерных массивов.
  • Мы также заметили, что индексацию можно использовать для доступа и изменения элементов двумерных массивов.
  • Наконец, мы рассмотрели различные способы инициализации и объявления двумерных массивов в Java, а также некоторые распространенные ошибки в операторах объявления.

IB Информатика Java Двумерные массивы

IB Информатика Цели обучения

На этом уроке IB Информатика вы узнаете:

  • Создание таблиц данных с использованием двумерных массивов 2D-массив, чтобы сделать матричный объект

Табличные данные 2D

Иногда данные естественным образом поступают в двумерной форме:

  • Карты двумерные
  • Макет печатной страницы двумерный
  • Компьютерное изображение двухмерное размерный

Представьте себе класс из 7 учеников, которые проходят тест каждую неделю в течение 5 недель

В Java таблица может быть реализована в виде двумерного массива

  • Каждая ячейка массива представляет собой переменную, которая может содержать значение и работает как любая переменная
  • Как и в случае с одномерными массивами, каждая ячейка в двумерном массиве имеет один и тот же тип
  • Каждая ячейка массива указывается номером строки и столбца в указанном порядке
  • Скажем, что это похоже на таблицу выше
    • gradeTable[0][1] -> содержит значение 42
    • gradeTable[3][4] -> содержит значение 93

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

 

Важная информация

  • Предположим, у вас есть двумерный массив с N строк и M столбцов
  • Строки пронумерованы от 0 до N-1
  • Столбцы пронумерованы от 0 до M-1
  • Двумерный массив с N строками и M столбцов имеет N x M количество ячеек

Объявление и присвоение значений двумерному массиву

Как и в случае с одномерными массивами, существует множество способов инициализации двумерного массива

Пример хранения часов

Работодатель хранит часы, отработанные каждым из его сотрудников за каждый день недели, в файле с именем ehours.txt. Есть 3 сотрудника и данные хранятся за все 7 дней в течение недели. Ваша задача состоит в том, чтобы сложить общее количество часов, отработанных каждым сотрудником, и суммировать общее количество часов, отработанных всеми сотрудниками в каждый день недели. Покажите свои результаты в красивом виде.

Решение:

  • В этой задаче вам предлагается сложить строки и столбцы двумерного массива
  • Итак, мы считываем данные из файла непосредственно в двумерный массив
  • Складываем строки, используя loop
  • Сложите столбцы, используя другой вложенный цикл
  • Отобразите результаты, проявив некоторую изобретательность

Необходимые переменные

  • Переменная hours будет двумерным массивом для хранения сетки 7 x 3 рабочих часов

Чтение данных

  • В файле 7 строк данных и 7 строк в двумерном массиве, поэтому внешний цикл будет считать от 0 до 6.
  • Каждый раз в этом цикле необходимо считывать строку из файл
  • Поскольку в каждой строке есть 3 части данных, вы должны использовать класс StringTokenizer для создания токенов для этих 3 значений их
  • Для циклического просмотра и сохранения в массиве каждого значения столбца или токена вы можете использовать другой цикл, который подсчитывает от 0 до 2

Вычисление суммы для каждой строки

  • Сумма строк равна
    o hours[row][0] + hours[row][1] + hours[row][2]
  • Таким образом, вы можете используйте внешний цикл для каждой строки и внутренний цикл для сложения всех отдельных столбцов
  • В приведенном выше коде rowSum перезаписывается для каждой отдельной строки, поэтому, если вы каким-то образом не сохраните эти значения в массиве, вам придется печатать его значение на экран сразу после (см. полное решение)

Вычисление суммы каждого столбца

  • Сумма столбцов равна
    o hours[0][col] + hours[1][col] +…+ hours[6][col]
  • Таким образом, вы можете используйте внешний цикл для каждого столбца и внутренний цикл для сложения всех отдельных строк
  • В приведенном выше коде colSum перезаписывается для каждого отдельного столбца, поэтому, если вы не сохраните эти значения в массиве каким-либо образом, вам придется печатать его значение на экран сразу после (см. полное решение)

Полное решение

На практике выполните следующие действия

1. Генератор шаблонов
Сгенерируйте таблицы со следующими шаблонами. Ваша программа должна работать с квадратной сеткой любого размера.

2. Треугольник Паскаля
Ниже показан так называемый треугольник Паскаля
• Здесь вся первая строка равна 0, за исключением первого столбца, который равен 1
• Весь первый столбец всегда равен 1
• Все остальные числа получаются добавление числа непосредственно над ним к числу по диагонали сверху и слева от него
o В позиции [8][4] значение равно 70, что равно 35 (Число непосредственно над своей позицией) + 21 (Число по диагонали выше и слева от своей позиции

Выполните следующие задачи:
• Используйте двухмерный массив для создания показанного выше треугольника Паскаля (явно назначьте первую строку и используйте вложенный цикл для создания всех последующих строк)
• Запишите треугольник Паскаля в файл без всех нулей
• Измените программу, чтобы она запрашивала пользователь сколько уровней треугольника отображать

Хотите узнать больше о компьютерных науках и программировании?

Ознакомьтесь с нашими курсами по программированию на Python, посвященными программированию на уровне старшей школы.

No related posts.