Многомерные массивы в java. Что такое массив? Как загрузить элементы в массив

Массив - это структура данных, которая предназначена для хранения однотипных данных. Массивы в Java работают иначе, чем в C/C++. Особенности:

Поскольку массивы являются объектами, мы можем найти их длину. Это отличается от C/C++, где мы находим длину с помощью sizeof.
Переменная массива может также быть .
Переменные упорядочены и имеют индекс, начинающийся с 0.
Может также использоваться как статическое поле, локальная переменная или параметр метода.
Размер массива должен быть задан значением int, а не long или short.
Прямым суперклассом типа массива является Object.
Каждый тип массива реализует интерфейсы Cloneable and java.io.Serializable.

Инициализация и доступ к массиву

Одномерные Массивы: общая форма объявления

Type var-name; или type var-name;

Объявление состоит из двух компонентов: типа и имени. type объявляет тип элемента массива. Тип элемента определяет тип данных каждого элемента.

Кроме типа int, мы также можем создать массив других типов данных, таких как char, float, double или определяемый пользователем тип данных (объекты класса).Таким образом, тип элемента определяет, какой тип данных будет храниться в массиве. Например:

// both are valid declarations int intArray; or int intArray; byte byteArray; short shortsArray; boolean booleanArray; long longArray; float floatArray; double doubleArray; char charArray; // an array of references to objects of // the class MyClass (a class created by // user) MyClass myClassArray; Object ao, // array of Object Collection ca; // array of Collection // of unknown type

Хотя приведенное выше первое объявление устанавливает тот факт, что intArray является переменной массива, массив фактически не существует. Он просто говорит компилятору, что эта переменная типа integer.

Чтобы связать массив int с фактическим физическим массивом целых чисел, необходимо обозначить его с помощью new и назначить int.

Как создать массив в Java

При объявлении массива создается только ссылка на массив. Чтобы фактически создать или предоставить память массиву, надо создать массив следующим образом: общая форма new применительно к одномерным и выглядит следующим образом:
var-name = new type ;

Здесь type указывает тип данных, size — количество элементов в массиве, а var-name-имя переменной массива.

Int intArray; //объявление intArray = new int; // выделение памяти

Int intArray = new int; // объединение

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

Литералы массива

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

Int intArray = new int{ 1,2,3,4,5,6,7,8,9,10 }; // Declaring array literal

Длина этого массива определяет длину созданного массива.
Нет необходимости писать int в последних версиях Java

Доступ к элементам массива Java с помощью цикла for

Доступ к каждому элементу массива осуществляется через его индекс. Индекс начинается с 0 и заканчивается на (общий размер)-1. Все элементы могут быть доступны с помощью цикла for.

For (int i = 0; i < arr.length; i++) System.out.println("Element at index " + i + " : "+ arr[i]);

// Пример для иллюстрации создания array
// целых чисел, помещает некоторые значения в массив,
// и выводит каждое значение.

class GFG
{

{

int arr;

// allocating memory for 5 integers.
arr = new int;

arr = 10;

arr = 20;

//so on...
arr = 30;
arr = 40;
arr = 50;

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
System.out.println("Element at index " + i +
" : "+ arr[i]);
}
}
В итоге получаем:

Element at index 0: 10 Element at index 1: 20 Element at index 2: 30 Element at index 3: 40 Element at index 4: 50

Массивы объектов

Массив объектов создается так же, как элементов данных следующим образом:

Student arr = new Student;

StudentArray содержит семь элементов памяти каждый из класса student, в котором адреса семи объектов Student могут быть сохранены. Student объекты должны быть созданы с помощью конструктора класса student и их ссылки должны быть присвоены элементам массива следующим образом:

Student arr = new Student;

// Java program to illustrate creating an array of
// objects

class Student
{
public int roll_no;
public String name;
Student(int roll_no, String name)
{
this.roll_no = roll_no;
this.name = name;
}
}

// Elements of array are objects of a class Student.
public class GFG
{
public static void main (String args)
{
// declares an Array of integers.
Student arr;

// allocating memory for 5 objects of type Student.
arr = new Student;

// initialize the first elements of the array
arr = new Student(1,"aman");

// initialize the second elements of the array
arr = new Student(2,"vaibhav");

// so on...
arr = new Student(3,"shikar");
arr = new Student(4,"dharmesh");
arr = new Student(5,"mohit");

// accessing the elements of the specified array
for (int i = 0; i < arr.length; i++)
System.out.println("Element at " + i + " : " +
arr[i].roll_no +" "+ arr[i].name);
}
}

Получаем:

Element at 0: 1 aman Element at 1: 2 vaibhav Element at 2: 3 shikar Element at 3: 4 dharmesh Element at 4: 5 mohit

Что произойдет, если мы попытаемся получить доступ к элементу за пределами массива?
Компилятор создает исключение ArrayIndexOutOfBoundsException, указывающее, что к массиву был получен доступ с недопустимым индексом. Индекс либо отрицательный, либо больше или равен размеру массива.

Многомерные

Многомерные массивы — это массивы массивов, каждый элемент которых содержит ссылку на другой массив. Создается путем добавления одного набора квадратных скобок () для каждого измерения. Рассмотрим пример:

Int intArray = new int; //a 2D array or matrix int intArray = new int; //a 3D array

class multiDimensional
{
public static void main(String args)
{
// declaring and initializing 2D array
int arr = { {2,7,9},{3,6,1},{7,4,2} };

// printing 2D array
for (int i=0; i< 3 ; i++)
{
for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + " ");

System.out.println();
}
}
}

Output: 2 7 9 3 6 1 7 4 2

Передача массивов в метод

Как и переменные, мы можем передавать массивы в методы.

// Java program to demonstrate // passing of array to method class Test { // Driver method public static void main(String args) { int arr = {3, 1, 2, 5, 4}; // passing array to method m1 sum(arr); } public static void sum(int arr) { // getting sum of array values int sum = 0; for (int i = 0; i < arr.length; i++) sum+=arr[i]; System.out.println("sum of array values: " + sum); } }

На выходе получим:

sum of array values: 15

Возврат массивов из методов

Как обычно, метод также может возвращать массив. Например, ниже программа возвращает массив из метода m1.

// Java program to demonstrate // return of array from method class Test { // Driver method public static void main(String args) { int arr = m1(); for (int i = 0; i < arr.length; i++) System.out.print(arr[i]+" "); } public static int m1() { // returning array return new int{1,2,3}; } }

Объекты класса

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

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args) { int intArray = new int; byte byteArray = new byte; short shortsArray = new short; // array of Strings String strArray = new String; System.out.println(intArray.getClass()); System.out.println(intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }

class +" "); } } }
Клон многомерного массива (например, Object ) является копией и это означает, что он создает только один новый массив с каждым элементом и ссылкой на исходный массив элементов, но вложенные массивы являются общими.
// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args) { int intArray = {{1,2,3},{4,5}}; int cloneArray = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray == cloneArray); System.out.println(intArray == cloneArray); } }

Массив — это множество однотипных объектов, которые имеют общее название. К каждому элементу массива возможен доступ по его индексу. Рассмотрим реальный пример. Пусть у нас есть некоторый склад, который называется a и пусть в нем есть некоторое количество ящиков, каждый из которых последовательно пронумерован. В каждом ящике лежит некоторый объект, который по своему типу совпадает с объектами в других ящиках. Пример данного склада является классическим массивом, где название склада — это название массива, ящики — это элементы массива, номера ящиков — это индексы элементов, а содержимое ящиков — это значения наших переменных. Представим, что внутри ящиков лежат лимоны, и в каждом ящике лежит определенное количество лимонов. Тогда, значения наших переменных будут показывать количество лимонов. Рассмотрим такой склад, состоящий из трех ящиков, пусть в первом ящике лежит 3, во втором 7, в третьем 273. Тогда, массив, описывающий данный склад можно изобразить следующим образом:

Индекс 0 1 2
Значение 3 7 273
Индексация в массиве всегда начинается с 0. Рассмотрим некоторые операции, которые можно производить с массивом:

Создание массива

Тип имяПеременной;
int a;//целочисленный массив
char b;//массив символов
String c;
Выделение памяти:
A = new int;//выделяем память под 10 элементов
b = new char;//выделяем память под 20 элементов
c = new String;//выделяем память под 30 элементов
Таким образом инициализация массива выглядит следующим образом:
Int a = new int;//инициализация массива целых чисел из 10 элементов
char b = new char;//инициализация массива символов из 20 элементов
String c = new String;//инициализация массива строк из 30 элементов
Всем элементам массива после такой инициализации присваивается значение по умолчанию.
Существует возможность сразу задать значения элементов массива, создадим массив, который будет показывать количество лимонов в ящике, как в примере выше:
Int a = new int{ 3, 7, 273 };

Работа с массивом

Считывание массива:
Import java.util.Scanner;
public class test {
public static void main(String args) {
int a;//массив целых чисел
int n;//количество элементов в массиве
Scanner in = new Scanner(System.in);
n = in.nextInt();
a = new int[n];
for(int i = 0; i Изменение значений массива:

for(int i = 0; i Вывод массива:
Int a;//массив целых чисел, который был как - то обработан
for(int i = 0; i Произвольный доступ к элементу массива по индексу:
System.out.println(a);//Выводим первый элемент массива
a = 1;//Присваиваем второму элементу массива 1
int temp = a;//Сохраняем значение третьего элемента массива в переменную temp
Вот так вот выглядят основные операции с массивами. Очень часто на различных уроках по информатике просят вынести эти этапы работы с массивом в отдельные функции, но про это мы поговорим позднее. Таким образом, с помощью считывания массива, мы можем ввести некоторые значение с консоли, с помощью изменения значений, мы можем например, увеличить все значения на единицу или умножить на два, а с помощью вывода мы можем вывести текущие значения массива. Если нам требуется работать только с конкретными элементами массива, то тут мы можем воспользоваться произвольным доступом по индексу, где индекс - это любое положительное целое число, которое меньше длины массива. Текущую длину массива можно получить с помощью свойства length, оно уже применялось при выводе массива.
Тут я опущу диалог про то, что массивы являются ссылками и работа с ними отличается от работы с обычными базовыми типами.

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

Не всегда бывает удобно нумеровать ящики на складе с 0 до определенного числа, иногда хочется привести склад в более упорядоченный вид, например ввести ряды. Теперь каждый ящик имеет свой номер ряда и свой порядковый номер в этом ряду. Пусть на нашем складе есть девять ящиков, которые имеют содержат 1, 2 и так далее 9 апельсинов. Ящики на складе располагаются в три ряда по три ящика, тогда ситуацию на складе можно представить так.

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

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

Пример двумерного прямоугольного массива Java:
Int multyArr; multyArr = new int; /* * multyArr structure * | (0,0) | (0,1) | * | (1,0) | (1,1) | */
Здесь объявлен и определен двумерный массив, имеющий две строки и два столбца.
Загрузим массив элементами:
MultyArr = 1; multyArr = 2; multyArr = 3; multyArr = 4;
Вывод двумерного массива (перебираем массив):
System.out.println("multyArr"); for(int inn = 0; inn < 2; inn++) { for(int jnn = 0; jnn < 2; jnn++) { System.out.println("multyArr[" + inn + "][" + jnn + "] = " + multyArr ); } }
Получаем:
for(int inn = 0; inn < 2; inn++)

мы проходим по рядам, а в цикле
for(int jnn = 0; jnn < 2; jnn++)

по столбцам.
Можно объявить и определить многомерный массив одновременно:
int multyArr = {{1,2}, {3,4}};

Длина многомерного массива в Java

Int multyArr = {{1,2}, {3,4}, {5,6}}; /* * multyArr structure * | 1 | 2 | * | 3 | 4 | * | 5 | 6 | */ System.out.println("Array length = " + multyArr.length);
Array length = 3

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

Трехмерный массив в Java

Пример трехмерного массива в Java:
int triArray;
triArray = new int;

Здесь объявлен и определен трехмерный массив. Его можно представит как куб, состоящий из двух слоёв (layer), каждый слой состоит из двух рядов и двух столбцов, т.е. каждый слой - это двумерный массив.
Как заполнить трехмерный массив? Можно в цикле, но мы для примера вручную заполним:
//**************** //THE FIRST LAYER //**************** //the first row of the first layer triArray = 1; triArray = 2; //the second row of the first layer triArray = 3; triArray = 4; //**************** //THE SECOND LAYER //**************** //the first row of the second layer triArray = 5; triArray = 6; //the second row of the second layer triArray = 7; triArray = 8;
Как вывести трехмерный массив? Или как перебрать трехмерный массив? Так.

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

Для примитивных типов:
Int myIntArray = new int; int myIntArray = {1,2,3}; int myIntArray = new int{1,2,3};
Для классов, например String , это то же самое:
String myStringArray = new String; String myStringArray = {"a","b","c"}; String myStringArray = new String{"a","b","c"};
Третий способ инициализации полезен, когда вы сначала объявляете массив, а затем инициализируете его. Приведение необходимо здесь.
String myStringArray; myStringArray = new String{"a","b","c"};
Существует два типа массива.

Один размерный массив

Синтаксис значений по умолчанию:
Int num = new int;
Или (менее предпочтительный)
Int num = new int;
Синтаксис с указанными значениями (инициализация переменной/поля):
Int num = {1,2,3,4,5};
Или (менее предпочтительный)
Int num = {1, 2, 3, 4, 5};
Примечание. Для удобства int num предпочтительнее, потому что в нем четко сказано, что вы говорите здесь о массиве. Иначе никакой разницы. Совсем нет.

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

Декларация
int num = new int;
Int num = new int;
Int num = new int;
Инициализация
num=1; num=2; num=1; num=2; num=1; num=2; num=1; num=2; num=1; num=2;
Int num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };
Ragged Array (или непрямоугольный массив)
int num = new int; num = new int; num = new int; num = new int; num = new int;
Итак, здесь мы явно определяем столбцы.
Другой способ:
Int num={ {1}, {1,2}, {1,2,3,4,5}, {1,2}, {1,2,3} };
Для доступа:
for (int i=0; i<(num.length); i++) { for (int j=0;jВ качестве альтернативы:
For (int a: num) { for (int i: a) { System.out.println(i); } }
Type variableName = new Type; Type variableName = {comma-delimited values}; Type variableName = new Type; Type variableName = {comma-delimited values};
также действителен, но я предпочитаю скобки после типа, потому что легче видеть, что тип переменной на самом деле является массивом.
Ниже показано объявление массива, но массив не инициализирован:
Int myIntArray = new int;
Ниже показано объявление, а также инициализация массива:
Int myIntArray = {1,2,3};
Теперь следующее также показывает объявление, а также инициализацию массива:
Int myIntArray = new int{1,2,3};
Но этот третий показывает свойство анонимного создания массива-объекта, которое указывается ссылочной переменной "myIntArray", поэтому, если мы пишем только "new int {1,2,3};" то это может быть анонимный массив-объект.

Если мы просто напишем:
Int myIntArray;
это не объявление массива, но следующий оператор делает следующее выражение завершенным:
MyIntArray=new int;
Я считаю полезным, если вы понимаете каждую часть:
Type name = new Type;
Type - это тип переменной, называемой именем ("имя" называется идентификатором). Литеральный "Тип" - это базовый тип, а скобки означают, что это тип массива этой базы. Типы массивов в свою очередь являются собственными, что позволяет создавать многомерные массивы типа Type (тип массива Type ). Ключевое слово new говорит о распределении памяти для нового массива. Число между скобкой говорит о том, насколько большой будет новый массив и сколько памяти будет выделено. Например, если Java знает, что базовый тип Type занимает 32 байта, и вам нужен массив размером 5, ему необходимо внутренне выделить 32 * 5 = 160 байт.

Вы также можете создавать массивы с уже имеющимися значениями, такими как
Int name = {1, 2, 3, 4, 5};
который не только создает пустое пространство, но и заполняет его этими значениями. Java может сказать, что примитивы являются целыми числами и что их 5, поэтому размер массива может быть определен неявно.
Кроме того, если вы хотите что-то более динамичное, есть интерфейс List. Это не будет работать, но более гибко:
List listOfString = new ArrayList(); listOfString.add("foo"); listOfString.add("bar"); String value = listOfString.get(0); assertEquals(value, "foo");
Существует два основных способа создания массива:

Этот, для пустого массива:
Int array = new int[n]; // "n" being the number of spaces to allocate in the array
И этот, для инициализированного массива:
Int array = {1,2,3,4 ...};
Вы также можете создавать многомерные массивы, например:
Int array2d = new int[x][y]; // "x" and "y" specify the dimensions int array2d = { {1,2,3 ...}, {4,5,6 ...} ...};
Возьмите примитивный тип int , например. Существует несколько способов объявления и массив int:
Int i = new int; int i = new int {value1, value2, value3, etc}; int i = {value1, value2, value3, etc};
где во всех этих случаях вы можете использовать int i вместо int i .

С отражением вы можете использовать (Type) Array.newInstance(Type.class, capacity);

Обратите внимание, что в параметрах метода... отображается variable arguments . По сути, любое количество параметров в порядке. Это проще объяснить с помощью кода:
Public static void varargs(int fixed1, String fixed2, int... varargs) {...} ... varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100} varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};
Внутри метода varargs рассматривается как нормальный int . Type... может использоваться только в параметрах метода, поэтому int... i = new int {} не будет компилироваться.

Обратите внимание, что при передаче int методу (или любому другому Type) вы не можете использовать третий способ. В заявлении int i = *{a, b, c, d, etc}* компилятор предполагает, что {...} означает int . Но это потому, что вы объявляете переменную. При передаче массива методу декларация должна быть либо new Type , либо new Type {...} .

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

Многомерные массивы гораздо сложнее справиться. По существу, 2D-массив представляет собой массив массивов. int означает массив int s. Ключ состоит в том, что если int объявлен как int[x][y] , максимальный индекс равен i . По существу, прямоугольник int равен:

Объявление массива ссылок на объекты:
Class Animal {} class Horse extends Animal { public static void main(String args) { /* * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed) */ Animal a1 = new Animal; a1 = new Animal(); a1 = new Horse(); /* * Array of Animal can hold Animal and Horse and all subtype of Horse */ Animal a2 = new Horse; a2 = new Animal(); a2 = new Horse(); /* * Array of Horse can hold only Horse and its subtype (if any) and not allowed supertype of Horse nor other subtype of Animal. */ Horse h1 = new Horse; h1 = new Animal(); // Not allowed h1 = new Horse(); /* * This can not be declared. */ Horse h2 = new Animal; // Not allowed } }
Массив - это последовательный список элементов
Int item = value; int one_dimensional_array = { value, value, value, .., value }; int two_dimensional_array = { { value, value, value, .. value }, { value, value, value, .. value }, .. .. .. .. { value, value, value, .. value } };
Если это объект, то это же понятие
Object item = new Object(); Object one_dimensional_array = { new Object(), new Object(), .. new Object() }; Object two_dimensional_array = { { new Object(), new Object(), .. new Object() }, { new Object(), new Object(), .. new Object() }, .. .. .. { new Object(), new Object(), .. new Object() } };
В случае объектов вам нужно либо назначить его null для инициализации с помощью new Type(..) , классы, такие как String и Integer , являются особыми случаями, которые будут обрабатываться как следующие
String a = { "hello", "world" }; // is equivalent to String a = { new String({"h","e","l","l","o"}), new String({"w","o","r","l","d"}) }; Integer b = { 1234, 5678 }; // is equivalent to Integer b = { new Integer(1234), new Integer(5678) };
В общем случае вы можете создавать массивы, которые M мерные
Int .. array = // ^ M times brackets {{..{ // ^ M times { bracket // this is array.. // ^ M times }}..} // ^ M times } bracket ;
Стоит отметить, что создание размерного массива M является дорогостоящим с точки зрения Space. Поскольку при создании массива M с N во всех измерениях общий размер массива больше, чем N^M , так как каждый массив имеет ссылку, а в M-размерности есть (M -1) -мерный массив ссылок. Общий размер выглядит следующим образом

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

Для наглядности картинка, взятая мною с The Java Tutorial .

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

Объявление массива в Java

При создании массива в Java первым делом его нужно объявить. Это можно сделать следующим образом:

Int myFirstArray;

Можно также объявить массив так:

Int mySecondArray;

Однако, это не приветствуется соглашением по оформлению кода в Java, поскольку скобки обозначают то, что мы имеем дело с массивом и логичнее, когда они находятся рядом с обозначением типа.

Исходя из данного примера, мы объявили 2 массива с именами myFirstArray и mySecondArray . Оба массива будут содержать элементы типа int .

Подобным образом можно объявить массив любого типа:

Byte anArrayOfBytes; short anArrayOfShorts; long anArrayOfLongs; float anArrayOfFloats; double anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; String anArrayOfStrings; ...

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

Массивы можно создавать не только из переменных базовых типов, но и из произвольных объектов.

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

Резервация памяти для массива и его инициализация.

Int myFirstArray; myFirstArray = new int;

В нашем примере мы создали массив из 15 элементов типа int и присвоили его ранее объявленной переменной myFirstArray .

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

Int myArray = new int;

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

MyFirstArray = 10; // инициализация первого элемента myFirstArray = 20; // инициализация второго элемента myFirstArray = 30; // и т.д.

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

For(int i = 0; i < 15; i++){ myFirstArray[i] = 10; }

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

Рассмотрим создание и инициализацию массива на следующем примере. В нем мы создаем массив, содержащий цифры 0-9 и выводим значения на консоль.

//создание и инициализация массива int numberArray = new int; for(int i = 0; i < 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Упрощенная форма записи

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

Int myColor = {255, 255, 0};

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

Определение размера массива

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

MyColor.length;

Данный код поможет нам узнать, что длина массива myColor равна 3.

Пример: Задано 4 числа, необходимо найти минимальное

Int numbers = {-9, 6, 0, -59}; int min = numbers; for(int i = 0; i < numbers.length; i++){ if(min>numbers[i]) min = numbers[i]; } System.out.println(min);

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

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

Дан массив размерности N, найти наименьший элемент массива и вывести на консоль (если наименьших элементов несколько — вывести их все).

В массиве из задания 2. найти наибольший элемент.

Поменять наибольший и наименьший элементы массива местами. Пример: дан массив {4, -5, 0, 6, 8}. После замены будет выглядеть {4, 8, 0, 6, -5}.

Найти среднее арифметическое всех элементов массива.