Как написать массив в java

#4. Вводный курс по языку программирования JAVA. Массивы

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

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

int[] arr;

Обратите внимание, размер не указан, так что мы еще не создали массив.

arr = new int[10];

Теперь мы создали новый массив размером 10. Мы можем проверить размер массива, выведя на экран его длину:

System.out.println(arr.length);

Так же мы можем получить доступ к массиву и установить значения:

arr[0] = 4; arr[1] = arr[0] + 5;

Счет элементов массива в Java начинается с нуля, то есть доступ к первому элементу можно получить по индексу 0 (например, arr[0]). Кроме того, как показано на примере, массив размером 5 будет заканчиваться на индексе 4, так как счет начинается с нуля.

int[] arr = new int[5] arr[4] = 4; // Получение доступа и присвоение значения последнему элементу

Есть также возможность создать массив с указанием значений в одну строку:

int[] arr = ;

Кстати, если вы попытаетесь вывести массив целиком на экран, получите что-то в этом роде: [I@f7e6a96.

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

System.out.println(Arrays.toString(arr));

Или напишите цикл, выводящий последовательно элементы массива.

for(int i=0; i

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

Java-массивы. Динамические массивы в Java

Массив — набор определённого числа однотипных элементов. Использование массива позволяет нам не создавать большое количество переменных, а создать всего лишь одну переменную, имеющую вид массива. В отличие от стандартных переменных массивы содержат больше, чем одно значение. В программировании это очень важно, ведь при разработке софта может потребоваться огромное количество данных.

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

Массив однороден, и во всех ячейках должны храниться элементы одного типа. Если это int, то мы говорим про массив целых чисел, который может содержать лишь целые числа. Массив строк будет содержать лишь строки, а массив, состоящий из элементов созданного класса Dog, может содержать лишь объекты Dog.

Как происходит объявление массива в Java

Как и любую переменную в Java, массив надо объявить. Для этого есть два способа. Первый больше отвечает стилю Java, второй является наследием языка C.

Вне зависимости от способа, dataType — это тип переменных в массиве. Посмотрите внимательно на примеры — в них объявлены 2 массива. Один предназначен для целых чисел типа int, другой — для объектов типа Object.

Можно сказать, что во время объявления массива ему присваивается как имя (ArrayName), так и тип переменных.

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

Чтобы создать массив в Java, нужно зарезервировать место в памяти, для чего используем оператор new:

 
new typeOfArray [length];
Здесь у нас typeOfArray — тип массива, length — длина массива или число ячеек, выраженное в целых числах (int). Но мы лишь выделили память под массив, не связав его ни с какой переменной, ранее объявленной. Как правило, сначала массив объявляют, потом создают:
 
int[] myArray; // объявление массива myArray = new int[10]; // создание массива, выделение памяти на 10 элементов типа int
Итак, объявлен массив из целых чисел с именем myArray. После объявления мы сообщили, что массив состоит из 10 ячеек. Но можно использовать и более сокращённый синтаксис:
 
int[] myArray = new int[10]; // объявление и выделение памяти за один раз
Что же, мы создали массив с помощью new. После этого в его ячейках будут записаны значения по умолчанию. Например, для численных типов — это нули (0), для boolean — false, а если говорить о ссылочных типах, то null. Это значит, что после выполнения кода
 
int[] myArray = new int[10];
у нас на выходе будет массив из 10 целых чисел, причём в каждой ячейке будет записан 0.
Длина массива length
Длина массива — число элементов, под которое этот массив рассчитан. Длину массива изменить после создания нельзя.
Ещё нюанс: элементы массива в Java нумеруются с нуля. Таким образом, массив на 10 элементов состоит из чисел в диапазоне 0-9.

Если нужно получить доступ к длине нашего массива, используют переменную length:
 
int[] myArray = new int[10]; // создали массив, присвоили имя myArray System.out.println(myArray.length); // вывели в консоль длину массива
 
Вывод программы: 10
Инициализация массива
Инициализация — это заполнение массива конкретными данными, а не данными по умолчанию.
Нижеследующий код позволит создать массив, включающий в себя 4 сезона года. Также мы выполним заполнение массива строками-названиями сезонов:
 
String[] seasons = new String[4]; /* выполнили объявление и создание массива из 4 строк, где по умолчанию записано null, ведь строка — ссылочный тип данных*/ seasons[0] = "Winter"; /* в первую ячейку записали строку Winter*/ seasons[1] = "Spring"; /* во вторую ячейку (номер 1) записали строку Spring и т. д.*/ seasons[2] = "Summer"; seasons[3] = "Autumn";
Так мы записали названия всех сезонов. Но в принципе можно всё сделать проще, совместив инициализацию и объявление:
 
String[] seasons = new String[] ;
Или даже так, опустив оператор new:
 
String[] seasons = ;
Динамический массив в Java
Минус массива — статичность, то есть необходимость задавать размер заранее. Для этого и придумали динамический массив, который может менять размер в процессе выполнения программы. Например, статические массивы работают по следующей схеме:

А динамические массивы в Java функционируют несколько иначе:

Так как для копирования массива используется специальная нативная функция, проблем с «переездом» не возникает.
В общем, как вы уже догадались, динамические массивы применяются во время обработки наборов однородных данных, размер которых на момент написания программы нам неизвестен.
Массивы в Java – определение и создание, инициализация и заполнение
Массив — это структура данных, которая предназначена для хранения однотипных данных. Массивы в Java работают иначе, чем в C/C++. Особенности:

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

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

В этой статье вы узнаете
Инициализация и доступ к массиву
Одномерные Массивы: общая форма объявления
[java]type var-name[]; 
или 
type[] var-name;[/java]
Объявление состоит из двух компонентов: типа и имени. 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 [size];
Здесь type указывает тип данных, size – количество элементов в массиве, а var-name-имя переменной массива.
int intArray[]; //объявление intArray = new int[20]; // выделение памяти
int[] intArray = new int[20]; // объединение

Важно знать, что элементы массива, выделенные функцией 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.
// accessing the elements of the specified array for (int i = 0; i < arr.length; i++) System.out.println("Element at index " + i + " : "+ arr[i]);
// Пример для иллюстрации создания array 
// целых чисел, помещает некоторые значения в массив, 
// и выводит каждое значение.
class GFG 
 public static void main (String[] args) 
 // declares an Array of integers. 
int[] arr;
// allocating memory for 5 integers. 
arr = new int[5];
// initialize the first elements of the array 
arr[0] = 10;
// initialize the second elements of the array 
arr[1] = 20;
//so on… 
arr[2] = 30; 
arr[3] = 40; 
arr[4] = 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[7];
StudentArray содержит семь элементов памяти каждый из класса student, в котором адреса семи объектов Student могут быть сохранены. Student объекты должны быть созданы с помощью конструктора класса student и их ссылки должны быть присвоены элементам массива следующим образом:
Student arr = new Student[5];
// 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[5];
// initialize the first elements of the array 
arr[0] = new Student(1,”aman”);
// initialize the second elements of the array 
arr[1] = new Student(2,”vaibhav”);
// so on… 
arr[2] = new Student(3,”shikar”); 
arr[3] = new Student(4,”dharmesh”); 
arr[4] = 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[10][20]; //a 2D array or matrix int[][][] intArray = new int[10][20][10]; //a 3D array
class multiDimensional 
 public static void main(String args[]) 
 // declaring and initializing 2D array 
int arr[][] = < ,, >;
// printing 2D array 
for (int i=0; i < 3 ; i++)
 for (int j=0; j < 3 ; j++)
System.out.print(arr[i][j] + ” “);
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[] = ; // 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[]; > >
Объекты класса
Каждый массив имеет связанный объект класса, совместно используемый со всеми другими массивами с тем же типом компонента.
// Java program to demonstrate // Class Objects for Arrays class Test < public static void main(String args[]) < int intArray[] = new int[3]; byte byteArray[] = new byte[3]; short shortsArray[] = new short[3]; // array of Strings String[] strArray = new String[3]; 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()); >>

Output:
class [I 
class java.lang.Object 
class [B 
class [S 
class [Ljava.lang.String;

Теперь, как вы знаете, что массивы являются объектом класса. Членами массива являются следующие элементы:

Конечная длина открытого поля, содержащего количество компонентов. Длина может быть положительной или нулевой.
Все члены наследуются от класса Object; единственный метод объекта, который не наследуется, является метод clone.
Открытый метод clone () переопределяет метод clone в объекте класса.

Клонирование массивов
При клонировании одномерного массива, например Object[], выполняется копия с новым массивом, содержащим копии элементов исходного, а не ссылки.
// Java program to demonstrate // cloning of one-dimensional arrays class Test < public static void main(String args[]) < int intArray[] = ; int cloneArray[] = intArray.clone(); // will print false as deep copy is created // for one-dimensional array System.out.println(intArray == cloneArray); for (int i = 0; i < cloneArray.length; i++) < System.out.print(cloneArray[i]+" "); >> >

Клон многомерного массива (например, Object [] []) является копией и это означает, что он создает только один новый массив с каждым элементом и ссылкой на исходный массив элементов, но вложенные массивы являются общими.
// Java program to demonstrate // cloning of multi-dimensional arrays class Test < public static void main(String args[]) < int intArray[][] = ,>; 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[0] == cloneArray[0]); System.out.println(intArray[1] == cloneArray[1]); > >
Средняя оценка 3.8 / 5. Количество голосов: 8
Спасибо, помогите другим - напишите комментарий, добавьте информации к статье.
Или поделись статьей
Видим, что вы не нашли ответ на свой вопрос.
Помогите улучшить статью.
Напишите комментарий, что можно добавить к статье, какой информации не хватает.
Как написать массив в java
Массив является контейнерным объектом, который содержит постоянное число значений единственного типа. Длина массива устанавливается, когда массив создается. После создания фиксируется его длина. Вы уже видели пример массивов, в main метод "Привет Мир!" приложение. Этот раздел обсуждает массивы более подробно.
Массив десяти элементов
Каждый элемент в массиве вызывают элементом, и к каждому элементу получают доступ его числовым, индексируют. Как показано на вышеупомянутой иллюстрации, нумерация начинается 0. К 9-ому элементу, например, поэтому получили бы доступ в, индексируют 8.
Следующая программа, ArrayDemo , создает массив целых чисел, помещает некоторые значения в это, и печатает каждое значение к стандартному выводу.
class ArrayDemo < public static void main(String[] args) < // declares an array of integers int[] anArray; // allocates memory for 10 integers anArray = new int[10]; // initialize first element anArray[0] = 100; // initialize second element anArray[1] = 200; // etc. anArray[2] = 300; anArray[3] = 400; anArray[4] = 500; anArray[5] = 600; anArray[6] = 700; anArray[7] = 800; anArray[8] = 900; anArray[9] = 1000; System.out.println("Element at index 0: " + anArray[0]); System.out.println("Element at index 1: " + anArray[1]); System.out.println("Element at index 2: " + anArray[2]); System.out.println("Element at index 3: " + anArray[3]); System.out.println("Element at index 4: " + anArray[4]); System.out.println("Element at index 5: " + anArray[5]); System.out.println("Element at index 6: " + anArray[6]); System.out.println("Element at index 7: " + anArray[7]); System.out.println("Element at index 8: " + anArray[8]); System.out.println("Element at index 9: " + anArray[9]); >>
Вывод из этой программы:
Element at index 0: 100 Element at index 1: 200 Element at index 2: 300 Element at index 3: 400 Element at index 4: 500 Element at index 5: 600 Element at index 6: 700 Element at index 7: 800 Element at index 8: 900 Element at index 9: 1000
В реальной ситуации с программированием Вы, вероятно, использовали бы одну из поддерживаемых конструкций цикличного выполнения, чтобы выполнить итерации через каждый элемент массива, вместо того, чтобы записать каждую строку индивидуально как показано выше. Однако, этот пример ясно иллюстрирует синтаксис массива. Вы узнаете о различных конструкциях цикличного выполнения ( for , while , и do-while ) в разделе Потока управления.
Объявление, что Переменная Обращается к Массиву
Вышеупомянутая программа объявляет anArray со следующей строкой кода:
// declares an array of integers int[] anArray;
Как объявления для переменных других типов, у объявления массива есть два компонента: тип массива и имя массива. Тип массива пишется как type[] , где type тип данных содержавших элементов; квадратные скобки являются специальными символами, указывающими, что эта переменная содержит массив. Размер массива не является частью своего типа (который является, почему скобки пусты). Имя массива может быть чем-либо, что Вы хотите, при условии, что оно следует за правилами и соглашениями как ранее обсуждено в разделе именования. Как с переменными других типов, объявление фактически не создает массив — оно просто говорит компилятору, что эта переменная будет содержать массив указанного типа.
Точно так же можно объявить массивы других типов:
byte[] anArrayOfBytes; short[] anArrayOfShorts; long[] anArrayOfLongs; float[] anArrayOfFloats; double[] anArrayOfDoubles; boolean[] anArrayOfBooleans; char[] anArrayOfChars; String[] anArrayOfStrings;
Можно также поместить квадратные скобки после имени массива:
// this form is discouraged float anArrayOfFloats[];
Однако, соглашение препятствует этой форме; скобки идентифицируют тип массива и должны появиться с обозначением типа.
Создание, Инициализируя, и Получая доступ к Массиву
Один способ создать массив с new оператор. Следующий оператор в ArrayDemo программа выделяет массив с достаточным количеством памяти для десяти целочисленных элементов и присваивает массив anArray переменная.
// create an array of integers anArray = new int[10];
Если бы этот оператор отсутствовал, то компилятор напечатал бы ошибку как следующий, и компиляция перестала бы работать:
ArrayDemo.java:4: Variable anArray may not have been initialized.
Следующие немного строк присваивают значения каждому элементу массива:
anArray[0] = 100; // initialize first element anArray[1] = 200; // initialize second element anArray[2] = 300; // etc.
К каждому элементу массива получают доступ его числовым, индексируйте:
System.out.println("Element 1 at index 0: " + anArray[0]); System.out.println("Element 2 at index 1: " + anArray[1]); System.out.println("Element 3 at index 2: " + anArray[2]);
Альтернативно, можно использовать синтаксис ярлыка, чтобы создать и инициализировать массив:
int[] anArray = < 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 >;
Здесь длина массива определяется числом значений, обеспеченных между .
Можно также объявить массив массивов (также известный как многомерный массив) при использовании двух или больше наборов квадратных скобок, такой как String[][] names . К каждому элементу, поэтому, должно получить доступ соответствующее число, индексируют значения.
В языке программирования Java многомерный массив является просто массивом, компоненты которого являются самостоятельно массивами. Это непохоже на массивы в C или ФОРТРАНе. Последствие этого - то, что строкам позволяют измениться по длине, как показано по следующему MultiDimArrayDemo программа:
class MultiDimArrayDemo < public static void main(String[] args) < String[][] names = < , >; // Mr. Smith System.out.println(names[0][0] + names[1][0]); // Ms. Jones System.out.println(names[0][2] + names[1][1]); > >
Вывод из этой программы:
Mr. Smith Ms. Jones
Наконец, можно использовать встроенное length свойство, чтобы определить размер любого массива. Код
System.out.println(anArray.length);
напечатает размер массива к стандартному выводу.
Копирующие Массивы
System class имеет arraycopy метод, который можно использовать, чтобы эффективно скопировать данные с одного массива в другого:
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
Два Object параметры определяют массив, чтобы скопировать с и массив, чтобы скопировать в. Три int параметры определяют стартовую позицию в исходном массиве, стартовую позицию в целевом массиве, и число элементов массива, чтобы скопировать.
Следующая программа, ArrayCopyDemo , объявляет массив char элементы, произнося слово по буквам "decaffeinated". Это использует arraycopy скопировать подпоследовательность компонентов массива во второй массив:
class ArrayCopyDemo < public static void main(String[] args) < char[] copyFrom = < 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' >; char[] copyTo = new char[7]; System.arraycopy(copyFrom, 2, copyTo, 0, 7); System.out.println(new String(copyTo)); > >
Вывод из этой программы:
Читать:
Как получить стенд в stands awakening