Как ввести массив с клавиатуры java

Попробуем сделать подобное с массивом.

 int[] anyNumbers = ; int[] luckyNumbers = anyNumbers; luckyNumbers[2] = 25; mInfoTextView.setText("anyNumbers: " + Arrays.toString(anyNumbers) + "\nluckyNumbers: " + Arrays.toString(luckyNumbers)); 

 anyNumbers: [2, 8, 25]; luckyNumbers: [2, 8, 25]; 

Мы скопировали первый массив в другую переменную и в ней поменяли третий элемент. А когда стали проверять значения у обоих массивов, то оказалось, что у первого массива тоже поменялось значение. Но мы же его не трогали! Магия. На самом деле нет, просто массив остался прежним и вторая переменная обращается к нему же, а не создаёт вторую копию. Помните об этом.

Если же вам реально нужна копия массива, то используйте метод Arrays.copyOf()

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

Практика

Хватит болтать. Давайте будем проверять все вышесказанное.

Напишем такой код:

 public void onClick(View view)

Запустите приложение и убедитесь, что четвёртому элементу массива cats[3] присвоено значение 0. Проверьте таким образом все элементы массива. Далее присвойте шестому элементу значение 7 и проверьте снова результат.

 int[] cats = new int[6]; cats[5] = 7; String result = String.valueOf(cats[5]); mInfoTextView.setText(result); 

Однако вернёмся к нашей картинке. У всех котов есть имена. Создадим массив из восьми строковых элементов и обратимся к одному из них:

 public void onClick(View v) < String[] catsNames = < "Васька", "Кузя", "Барсик", "Мурзик", "Леопольд", "Бегемот", "Рыжик", "Матроскин" >; mInfoTextView.setText(catsNames[6]); > 

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

Перебор значений массива

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

 int aNums[] = < 2, 4, 6 >; for (int i = 0; i < aNums.length; i++) < String strToPrint = "aNums[" + i + "] bg-light"> for (int num : aNums)

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

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

Для создания многомерных массивов используются дополнительные скобки:

 int[][] a = < < 1, 2, 3 >, < 4, 5, 6 >> 

Также массив может создаваться ключевым словом new:

 // трехмерный массив фиксированной длины int[][][] b = new int[2][4][4]; 

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

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

 String[][] arr = new String[4][3]; arr[0][0] = "1"; arr[0][1] = "Васька"; arr[0][2] = "121987102"; arr[1][0] = "2"; arr[1][1] = "Рыжик"; arr[1][2] = "2819876107"; arr[2][0] = "3"; arr[2][1] = "Барсик"; arr[2][2] = "412345678"; arr[3][0] = "4"; arr[3][1] = "Мурзик"; arr[3][2] = "587654321"; 

Представляйте двумерный массив как таблицу, где первые скобки отвечают за ряды, а вторые - за колонки таблицы. Тогда пример выше представляет собой таблицу из четырёх рядов и трёх колонок.

Для двумерных массивов часто используются два цикла for, чтобы заполнить элементы данными слева направо и сверху вниз. Напишем такой код:

 int[][] twoD = new int[3][4]; // объявили двухмерный массив int i, j, k = 0; for (i = 0; i < 3; i++) for (j = 0; j < 4; j++) < twoD[i][j] = k; k++; >for (i = 0; i

В данном примере мы сначала заполнили двухмерный массив данными, а затем снова прошлись по этому массиву для считывания данных.

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

Первое число в скобках обозначают ряд (строку), а второе число - столбец. Принято считать, что в массиве new int[M][N] первый размер означает количество строк, а второй - количество столбцов.

На экране после запуска примера мы увидим следующее:

 0 1 2 3 4 5 6 7 8 9 10 11 

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

 int[][] twoD = new int[3][]; // память под первое измерение // далее резервируем память под второе измерение twoD[0] = new int[4]; twoD[1] = new int[4]; twoD[2] = new int[4]; 

В данном примере особого смысла в этом нет.

Еще одна интересная особенность при создании массива связана с запятой. Посмотрите на пример.

 int[][] a = , ,>; System.out.println(Arrays.deepToString(a)); 

Вроде в конце используется лишняя запятая, но её наличие не приведёт к ошибке (только одна запятая). Это бывает удобно, когда надо скопировать или вставить кусок массива в коде. Кстати, метод deepToString() класса Arrays очень удобен для вывода двухмерных массивов.

Чтобы совсем сбить вас с толку, приведу ещё один правильный пример.

 Integer[] Integer[] = , ,>; System.out.println(Arrays.deepToString(Integer)); 

Я уже упоминал, что квадратные скобки можно использовать двумя способами. Сначала мы поставили скобки у типа переменной, а потом у имени переменной. При этом мы использовали в качестве имени имя класса Integer. Однако, Java догадывается, что на этот раз используется не класс, а имя и разрешает такой синтаксис. Но лучше так не выпендриваться.

Размер имеет значение

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

 int[][] matrix = new int[4][5]; System.out.println(matrix.length); 

А если мы хотим узнать количество столбцов в ряду? Тогда указываете ряд, а затем вычисляете у него количество столбцов.

 // число колонок у третьего ряда System.out.println(matrix[2].length); 

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

Сложить два массива

Предположим, у вас есть два массива, и вам нужно их соединить и получить общий массив.

 private double[] concatArray(double[] a, double[] b)

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

 // метод для склеивания двух строковых массивов private String[] concatArray(String[] a, String[] b) < if (a == null) return b; if (b == null) return a; String[] r = new String[a.length + b.length]; System.arraycopy(a, 0, r, 0, a.length); System.arraycopy(b, 0, r, a.length, b.length); return r; >String[] week1 = new String[] < "Понедельник", "Вторник", "Среда" >; String[] week2 = new String[] < "Четверг", "Котопятница", "Субкота", "Воскресенье" >; String[] week = concatArray(week1, week2); // будет возвращён массив всех семи дней недели 

Взять часть массива

Аналогично, если вам нужно взять только часть из большого массива, то воспользуйтесь методом:

 // start - с какой позиции нужно получить новый массив, отсчёт с 0 private double[] copyPartArray(double[] a, int start) < if (a == null) return null; if (start >a.length) return null; double[] r = new double[a.length - start]; System.arraycopy(a, start, r, 0, a.length - start); return r; > public void onClick(View v) < double[] digits = new double[] ; double[] part = copyPartArray(digits, 1); Toast.makeText(v.getContext(), part[1] + "", Toast.LENGTH_LONG).show(); > 

Здесь вы также можете использовать другие типы вместо double. Вот пример использования:

 private String[] copyPartArray(String[] a, int start) < if (a == null) return null; if (start >a.length) return null; String[] r = new String[a.length - start]; System.arraycopy(a, start, r, 0, a.length - start); return r; > public void onClick(View v) < String[] weekday = new String[] < "Понедельник", "Вторник", "Среда" >; // нам нужен массив со второго элемента String[] week = copyPartArray(weekday, 1); // вернёт Вторник и Среда // выводим второй элемент из полученного массива, т.е. Среда Toast.makeText(v.getContext(), week[1], Toast.LENGTH_LONG).show(); > 

Перемешать элементы массива

Бывает необходимость перемешать элементы массива в случайном порядке. В интернете нашёл готовый метод по алгоритму Fisher–Yates (прим.: Fisher - это рыбак, который ловит рыбу, например, кот)

 // Implementing Fisher–Yates shuffle static void shuffleArray(int[] ar) < Random rnd = new Random(); for (int i = ar.length - 1; i >0; i--) < int index = rnd.nextInt(i + 1); // Simple swap int a = ar[index]; ar[index] = ar[i]; ar[i] = a; >> // создадим массив и перемешаем его int[] mSolutionArray = < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 >; shuffleArray(mSolutionArray); Log.i("Array", Arrays.toString(mSolutionArray)); 

Подводим итоги

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

При выходе за границу массива происходит исключение RuntimeException, свидетельствующее об ошибке программиста.

Метод arraycopy() - Копирование массива

Стандартная библиотека Java содержит статический метод System.arraycopy(), который копирует массивы значительнее быстрее, чем при ручном копировании в цикле for.

В аргументах arraycopy() передаётся исходный массив, начальная позиция копирования в исходном массиве, приёмный массив, начальная позиция копирования в приёмном массиве и количество копируемых элементов. Любое нарушение границ массива приведёт к исключению.

Разработчик Avi Yehuda написал программу, которая вычисляет время на копирование с помощью цикла for и с помощью метода arraycopy() на примере с миллионом элементов. Ручное копирование у него заняло 182 мс, с помощью метода arraycopy() - 12 мс. Разница колоссальна.

 public class ArrayCopyTestActivity extends Activity < private static final int SIZE_OF_ARRAY = 1000000; private long time; @Override public void onCreate(Bundle savedInstanceState) < super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Integer [] sourceArray = new Integer[SIZE_OF_ARRAY]; Integer [] dst = new Integer[SIZE_OF_ARRAY]; fillArray(sourceArray); startBenchmark(); naiveCopy(sourceArray,dst); stopBenchmark(); startBenchmark(); System.arraycopy(sourceArray, 0, dst, 0, sourceArray.length); stopBenchmark(); >private void naiveCopy(Integer [] src, Integer [] dst) < for (int i = 0; i < src.length; i++) < dst[i]=src[i]; >> private void fillArray(Integer [] src) < for (int i = 0; i < src.length; i++) < src[i]=i; >> private void startBenchmark() < time = System.currentTimeMillis(); >private void stopBenchmark() < time = System.currentTimeMillis() - time; Log.d("array copy test", "time text-warning" >Поиск элементов строкового массива по начальным символам 
Допустим, у нас есть строковый массив и нам нужно по первым символам найти все слова, которые входят в данный массив.
 
 // Сам метод public static ArrayList searchFromStart(String[] inputArray, String searchText) < ArrayListoutputArray = new ArrayList<>(); for (int i = 0; i < inputArray.length; i++) < if (searchText.compareToIgnoreCase(inputArray[i].substring(0, searchText.length())) == 0) < outputArray.add(inputArray[i]); >> return outputArray; > // Массив строк final String[] catNamesArray = new String[] < "Рыжик", "Барсик", "Мурзик", "Мурка", "Васька", "Томасина", "Бобик", "Кристина", "Пушок", "Дымка", "Кузя", "Китти", "Барбос", "Масяня", "Симба" >; // Применим метод. Ищем по буквам "мур":
 List words = searchFromStart(catNamesArray, "мур"); Toast.makeText(getApplicationContext(), words.get(0).toString() + ":" + words.get(1).toString(), Toast.LENGTH_SHORT).show(); 
Вернёт списочный массив из двух элементов: Мурзик и Мурка.
Класс Arrays
Класс java.util.Arrays предназначен для работы с массивами. Он содержит удобные методы для работы с целыми массивами:

copyOf() − предназначен для копирования массива
copyOfRange() − копирует часть массива
toString() − позволяет получить все элементы в виде одной строки
sort() — сортирует массив методом quick sort
binarySearch() − ищет элемент методом бинарного поиска
fill() − заполняет массив переданным значением (удобно использовать, если нам необходимо значение по умолчанию для массива)
equals() − проверяет на идентичность массивы
deepEquals() − проверяет на идентичность массивы массивов
asList() − возвращает массив как коллекцию

Сортировка массива
Сортировка (упорядочение по значениям) массива a производится методами Arrays.sort(a) и Arrays.sort(a, index1, index2). Первый метод упорядочивает в порядке возрастания весь массив, второй — часть элементов (от индекса index1 до индекса index2). Имеются и более сложные методы сортировки. Элементы массива должны быть сравниваемы (поддерживать операцию сравнения).
Простой пример
 // задаём числа в случайном порядке int[] numbers = new int[]; // сортируем Arrays.sort(numbers); // проверяем mInfoTextView.setText(Arrays.toString(numbers)); 
Сортировка массива для ArrayAdapter

Массивы часто используются в адаптерах для заполнения данными компоненты Spinner, ListView и т.п.
Предположим, у вас есть массив строк и его нужно отсортировать перед отдачей массива адаптеру ArrayAdapter. Это позволит вывести строки в упорядоченном виде, например, в ListView:
 String[] catsNames = < "Васька", "Кузя", "Барсик", "Мурзик", "Леопольд", "Бегемот", "Рыжик", "Матроскин" >; // Сортируем перед передачей адаптеру Arrays.sort(catsNames); ArrayAdapter adapter; adapter = new ArrayAdapter<>( this, android.R.layout.simple_list_item_1, catsNames); setListAdapter(adapter); 
У метода sort() есть перегруженные версии, где можно указать диапазон массива, в пределах которого следует произвести сортировку.
Копирование массивов
Метод Arrays.copyOf(оригинальный_массив, новая_длина) — возвращает массив-копию новой длины. Если новая длина меньше оригинальной, то массив усекается до этой длины, а если больше, то дополняется нулями.






 // первый массив int[] anyNumbers = ; // копия второго массива int[] luckyNumbers = Arrays.copyOf(anyNumbers, anyNumbers.length); luckyNumbers[2] = 25; mInfoTextView.setText("anyNumbers: " + Arrays.toString(anyNumbers) + "\nluckyNumbers: " + Arrays.toString(luckyNumbers)); 
Теперь первый массив останется без изменений, а со вторым массивом делайте что хотите. Смотрим на результат.
 anyNumbers: [2, 8, 11]; luckyNumbers: [2, 8, 25]; 
Можно создать увеличенную копию, когда копируются все значения из маленького массива, а оставшиеся места заполняются начальными значениями, например, нулями.
 // три элемента int[] small_array = ; // создадим массив с пятью элементами int[] big_array = Arrays.copyOf(small_array, 5); mInfoTextView.setText("big_array: " + Arrays.toString(big_array)); 
 big_array: [1, 2, 3, 0, 0] 
Метод Arrays.copyOfRange(оригинальный_массив, начальный_индекс, конечный_индекс) — также возвращает массив-копию новой длины, при этом копируется часть оригинального массива от начального индекса до конечного –1.
 // Массив из четырёх элементов String[] array_1 = < "Васька", "Мурзик", "Рыжик", "Барсик">; // Сортировка массива Arrays.sort(array_1); // Копируем первые три элемента массива во второй массив String[] array_2 = Arrays.copyOf(array_1, 3); // Копируем нужные элементы из первого массива // в диапазоне от второго элемента до последнего в третий массив String[] array_3 = Arrays.copyOfRange(array_1, 2, array_1.length); Log.i(TAG, Arrays.toString(array_1)); Log.i(TAG, Arrays.toString(array_2)); Log.i(TAG, Arrays.toString(array_3)); 
Метод Arrays.toString()
Если использовать вызов метода toString() непосредственно у массива, то получите что-то непонятное и нечитаемое.
 String[] catNames = < "Васька", "Мурзик", "Рыжик", "Барсик">; Log.i(TAG, catNames.toString()); // Вернёт [Ljava.lang.String;@4222bd88 
Метод Arrays.toString(массив) возвращает строковое представление массива со строковым представлением элементов, заключённых в квадратные скобки. В примерах выше мы уже вызывали данный метод.
Метод deepToString() удобен для вывода многомерных массивов. Этот метод мы также уже использовали выше.
Метод Arrays.fill() - наполнение массива одинаковыми данными
Метод Arrays.fill() позволяет быстро заполнить массив одинаковыми значениями. У метода есть восемнадцать перегруженных версий для разных типов и объектов.
Метод fill() просто дублирует одно заданное значение в каждом элементе массива (в случае объектов копирует одну ссылку в каждый элемент):
 int size = 4; boolean[] test1 = new boolean[size]; int[] test2 = new int[size]; String[] test3 = new String[size]; Arrays.fill(test1, true); // присваивем всем true Toast.makeText(getApplicationContext(), Arrays.toString(test1), Toast.LENGTH_LONG).show(); Arrays.fill(test2, 9); // присваиваем всем 9 Toast.makeText(getApplicationContext(), Arrays.toString(test2), Toast.LENGTH_LONG).show(); Arrays.fill(test3, "Мяу!"); // Ну вы поняли Toast.makeText(getApplicationContext(), Arrays.toString(test3), Toast.LENGTH_LONG).show(); 
Запустив код, вы увидите, что на экране по очереди выводятся значения:
[true, true, true, true] [9, 9, 9, 9] [Мяу!, Мяу!, Мяу!, Мяу!]
Можно заполнить данными в нужном интервале за два прохода:






 int size = 4; String[] test3 = new String[size]; Arrays.fill(test3, "Мяу! "); Arrays.fill(test3, 2, 3, "Гав!"); Toast.makeText(getApplicationContext(), Arrays.toString(test3), Toast.LENGTH_LONG).show(); 
Сначала массив заполнится мяуканьем кота 4 раза, а потом на третью позицию попадает слово Гав!:
[Мяу!, Мяу!, Гав!, Мяу!]
Как видите, метод заполняет весь массив, либо диапазон его элементов. Но получаемые одинаковые данные не слишком интересны для опытов, но пригодятся для быстрых экспериментов.
Метод equals() - сравнение массивов
Класс Arrays содержит метод equals() для проверки на равенство целых массивов. Чтобы два массива считались равными, они должны содержать одинаковое количество элементов, и каждый элемент должен быть эквивалентен соответствующему элементу другого массива.
Напишем код в своей учебной программе.
 // Создаем два массива int[] a1 = new int[10]; int[] a2 = new int[10]; // заполняем их девятками Arrays.fill(a1, 9); Arrays.fill(a2, 9); mInfoTextView.setText("Сравним: " + Arrays.equals(a1, a2)); 
Мы создали два массива и заполнили их одинаковыми числами. При сравнении мы получим true. Добавим в код строчку кода, которая заменит один элемент во втором массиве:
 //Изменим один элемент у второго массива a2[3] = 11; mInfoTextView.setText("Сравним: " + Arrays.equals(a1, a2)); 
Теперь при сравнении будет выдаваться false.
Задачи
Решите задачи. Ответы доступны зарегистрированным пользователям.
Имеется массив из четырёх чисел int[] numbers = ;. Поменяйте местами первый и второй элемент массива. (Ответ)
Создайте массив из всех чётных чисел от 2 до 30 и выведите элементы массива на экран.






Создайте массив из всех нечётных чисел от 1 до 99, выведите его на экран в строку, а затем этот же массив выведите на экран тоже в строку, но в обратном порядке (99 97 95 93 … 7 5 3 1).
Создайте массив из 20-ти первых чисел Фибоначчи и выведите его на экран. Напоминаем, что первый и второй члены последовательности равны единицам, а каждый следующий — сумме двух предыдущих.
Найти максимальное значение из массива
Задача: Имеется статистика, сколько мышей поймал кот Барсик за год по месяцам в виде массива:
 int[] mice = new int[] < 4, 9, 3, 22, 5, 18, 25, 7, 11, 15, 5, 19 >; 
Написать метод getMax(), который вычисляет максимальное значение из массива. Ну и метод getMin() для нахождения минимального значения.
Найти три наибольших числа из массива
Похожая задача - найти три наибольших числа из массива mice (предыдущая задача).
Перестановка элементов массива в обратном порядке
Задача: Имеется массив, нужно переставить элементы массива в обратном порядке.
 int[] mice = new int[] < 4, 9, 3, 22, 5, 18, 25, 7, 11, 15, 5, 19 >; 
Поместить нули в конец массива
Дан массив с числами 5, 4, 3, 0, 6, 0, 0, 5, 6, 0, 25, 0, 8, 7, 3, 0, 1, 1, 0, 6, 4. Переместить все нули в конец массива.
Поместить нули в начало массива
Дан массив с числами 5, 4, 3, 0, 6, 0, 0, 5, 6, 0, 25, 0, 8, 7, 3, 0, 1, 1, 0, 6, 4. Переместить все нули в начало массива.
Найти индекс числа из массива
Есть массив, нужно определить индекс числа, который входит в этот массив.
Массивы в Java






В статье "Переменные в Java.Создание переменной" мы говорили о том, что переменная - это некоторый контейнер , в котором может храниться значение для дальнейшего использования в программе.


обычная переменная может содержать только 1 значение .
массив - это простая переменная, которая может содержать неодно, а сразу несколько значений, в отличие от обычной переменной, содержащей единственное значение. Массив - это такой себе "магический" контейнер, в который мы можем положить сразу несколько значений ("коробочек").

Ниже приводим Вам примеры массивов.
Пример №1

Как видите, мы создали целочисленный массив, который назвали array1 и присвоили три числа: 5, 17, 350
Пример №2

Как видите, мы создали строковый массив, который назвали array2 и присвоили слово "Java " и фразу "is the best". Причем мы их написали в двойных кавычках, потому что это массив типа String.
Любой массив имеет длину 
Например, длина этого массива = 3. Потому что в массиве 3 числа: 5, 17, 350







А длина этого массива = 2. Потому что в массиве 2 значения: "Java " и "is the best"

Если сказать проще, то длина массива - это количество элементов, которые в нем хранятся (количество маленьких "коробочек" в большой).
 Предлагаем теперь Вам ответить какая длина у этих 3 массивов? 
 

Правильные ответы: 

Длина этого массива 6. Потому что в этом массиве 6 чисел: 1, 8, 15, 30, 2, 3







Длина этого массива 2. Потому что в массиве 2 числа: 1 и 3

Длина этого массива 4. Потому что в массиве 4 слова: "Киев", "Львов", "Луцк", "Одесса".
А как сделать так, чтоб автоматически получать длину массива? 
Подсчитывать вручную количество элементов в массиве - это хорошо, но что, если элементов очень много. Вряд ли у Вас хватит терпения подсчитать 3 000 элементов. Если использовать свойство массива length , длина массива будет подсчитана автоматически.
Например, у нас есть вот такой массив.

Пишем int k = array1.length; .
В результате создастся переменная k, в которой будет лежать значение 3.
Попробуйте запустить вот этот код, чтоб убедиться в этом на практике:
class Test <
public static void main ( String [ ] args ) <
int [ ] array1 = < 5 , 17 , 350 >;

int k = array1 . length ;

System . out . println ( k ) ;
В любом массиве значения элементов сохраняются под порядковыми номерами (индексами) 
Причем нумерация начинается с "нуля" . Предлагаем рассмотреть на примерах.
Пример №1
В данном массиве:
5 - это элемент с порядковым номером 0
17 - это элемент с порядковым номером 1
350 - это элемент с порядковым номером 2

Пример №2
В данном массиве:
"Java " - это элемент с порядковым номером 0
"is the best" - это элемент с порядковым номером 1

Если Вы очень любите сладости, то можете представить массив в виде макаронов.

То есть индекс элемента - это его номер по порядку "минус" 1.
Как видно, длина массива из макаронов =3. И применяется та же логика к порядковым номерам (индексам) в массиве.
Давайте разберемся зачем в массиве значения элементов сохраняются под порядковыми номерами (индексами)? 
А ответ очень и очень простой. Чтобы можно было обращаться к конкретным элементам массива по индексу. Поскольку из того, что мы в большую коробку хаотично накидаем другие коробки, толку мало. Нам нужно знать, где лежит маленькая коробка с тем, что нам нужно. По этому все, что мы кладем в большую коробку, имеет свой номер.
Для того, чтобы получить то, что лежит в маленькой коробочке, нам нужно обратится к ней по индексу. Для этого пишем название переменной (большая коробка), после чего без пробелов в квадратных скобках индекс коробки.
Давайте рассмотрим это на практике.

Как мы можем обратиться к элементу массива array1 под индексом 0? Ответ: array1[0]
Как мы можем обратиться к элементу массива array1 под индексом 1? Ответ: array1[1]
Как мы можем обратиться к элементу массива array1 под индексом 2? Ответ: array1[2]


А как создать пустой массив? 

Во всех предыдущих примерах мы создавали массив и сразу инициализировали его какими-то значениями. Однако есть возможность сначала создать массив нужного размера, а позже наполнять его значениями (если нам при создании не известно, какие значения там будут находиться). Например, врач говорит женщине, что у нее будет двойня, но какого пола будут дети пока не известно. Вот Вам массив на 2 элемента типа "ребенок", но значения пока не известны.
Чтобы создать такой массив, нужно воспользоваться ключевым словом new. Теперь создание массива будет выглядеть так:
тип [] название = new тип[размер];
Запомните, что тип до "равно" и после, если мы говорим о массиве из примитивных типов, должны быть одинаковыми! 
В будущем мы увидим, что это правило может нарушаться, но это уже другая история.
В программе это выглядело бы вот так:


Похожие публикации:

Как включить lite mode xiaomi redmi 9a
Как задать расстояние между ячейками в таблице html
Как переводится yamaha
Как удалить обновление windows 10