Массивы в java — шпаргалка для новичков
Содержание:
Java Array example
In this Java array program, We will declare an integer array of size ten. Then we will sum those ten array values and displays the output.
In this Java array example Program, We declared 1 One Dimensional Arrays anIntegerArray[] with 10 elements and also declared i to iterate the Array elements,
Below For loop iterate every cell in the anIntegerArray array. The condition inside the for loops (i < anIntegerArray.length) will ensure the Jcompiler not exceed the array limit.
- Sum = Sum + anIntegerArray; statement is used to add each and individual array element present in the anIntegerArray to Sum variable.
- System.out.format statement displays the Sum value after every iteration.
- anIntegerArray.length finds the length of an array.
Java Array First Iteration: The value of i will be 0, and the condition (i < 10) is True. So, it will start executing the statements inside the loop.
Sum = Sum + anIntegerArray
=> Sum + anIntegerArray
Sum = 0 + 10 = 10
The value of i will be incremented by 1
Second Iteration: The value of i is 1, and the condition (1 < 10) is True.
Sum = Sum + anIntegerArraySum = 10 + 20 = 30
Third Iteration: After the increment, the value of i is 2, and the condition (2 < 10) is True.
Sum += anIntegerArray=> 30 + 30 = 60
Fourth Iteration: The value of i is 3, and the condition (3 < 5) is True.
Sum = Sum + anIntegerArraySum = 60 + 40 = 100
Fifth Iteration: The value of i is 4, and the condition (4 < 10) is True.
Sum = Sum +anIntegerArray=> 100 + 50 = 150
Sixth Iteration: The value of i is 5, and the condition (5 < 10) is True.
Sum += anIntegerArraySum = 150 + 60 = 210
Seventh Iteration: After increment, i = 6, and the condition (6 < 10) is True.
Sum = Sum + anIntegerArray => 210 + 70 = 280
Eighth Iteration: The value of i is 7, and the condition (7 < 10) is True.
Sum = Sum + anIntegerArray => 280 + 80 = 360
9th Iteration: i is 8, and the condition (8 < 10) is True.
Sum = Sum + anIntegerArray => 360 + 90 = 450
10th Iteration: i is 9 and the condition (9 < 10) is True.
Sum = Sum + anIntegerArraySum = 450 + 100 = 550
11th Iteration: The value of i is 10, and the condition (10 < 10) is False. So, it will exit from the for loop.
Lastly, we used System.out.format statement to display the Sum
Многомерные Java-массивы
Массивы, у которых только один индекс называется одномерным, мы уже рассмотрели. Но в них можно помещать не только примитивные типы данных и ссылки на объекты, но и другие массивы. В таком случае их называют многомерными.
Давайте на примере выясним, что они из себя представляют. Предположим, нам нужен массив для хранения числа имеющихся свободных мест в кинотеатре. Вот визуальное представление того, о чем я говорю:
Структура многомерного массива в Java (здесь мы видим свободные места в кинотеатре)
Конечно в реальной жизни кинотеатр был бы больше, но этот нам как раз подойдет в качестве примера.
— означает, что место доступно, 1 — что занято. Мы также могли бы добавить еще и 2 для зарезервированных мест и так далее. Но пока ограничимся более простым примером.
Java не предоставляет никакой специальной поддержки для многомерных массивов, но мы можем легко объявить их как массив массивов. Это будет выглядеть вот так:
int [] [] cinema = новый int ;
Первое число указывает количество столбцов, второе — количество строк. Все числовые массивы в Java автоматически инициализируются нулевыми значениями после объявления. Мы только что создали таблицу, полную нулей.
Теперь давайте заполним кинозал единицами, как на картинке выше. Для создания строки из единиц используем несколько циклов . Чтобы открыть доступ к элементам 2D-массива, мы должны ввести координаты столбцов и строк:
cinema = 1; // центр
for (int i = 1; i < 4; i++) { // четвертая строка
cinema = 1;
}
for (int i = 0; i < 5; i++) { // последняя строка
cinema = 1;
}
Нужно иметь в виду, что если мы запросим , он будет содержать количество столбцов (длину внешнего массива, представляющего столбцы). Чтобы определить количество строк (длину внутреннего массива), необходимо запросить cinema
Обратите внимание, что для работы должен быть хотя бы один столбец
Мы будем вкладывать циклы по порядку, чтобы внешний цикл проходил по строкам, а внутренний — по столбцам текущей строки. После вывода строки в консоль мы должны разорвать ее, ведь оба цикла должны иметь разные управляющие переменные:
for (int j = 0; j < cinema.length; j++) {
for (int i = 0; i < cinema.length; i++) {
System.out.print(cinema);
}
System.out.println();
}
Результат:
00000 00000 00100 01110 11111
Иногда может быть полезно создать массив с большим количеством измерений. Например, трехмерный. Вернемся к примеру с кинотеатром. Теперь представим, что в нем несколько этажей. Схематично это будет выглядеть так:
3D-массив
Давайте создадим 3D-массив:
int [] [] [] cinemas = новый int ;
Доступ к элементам приведенного выше трехмерного массива мы можем получить, как и раньше, через индекс, но теперь нам нужно ввести три координаты:
cinemas = 1; // кинотеатр на втором этаже, третий ряд, четвертое место
В такой ситуации, если мы запросим , то получим количество этажей.
Java Array Introduction
For example, an integer array in Java will store all the integer elements. If you try to insert a float or char value, then it will throw an error.
The length of a Java array decided when we are creating an array. Once it created, the length is fixed. We have 3 types of arrays in Java Programming
- One Dimensional Array
- Two Dimensional Array
-
Multi-Dimensional Array
- Three Dimensional Array
- Four Dimensional Array etc
Java array declaration or Syntax
The following code snippet will show you the most basic way of Java array declaration:
- Data_type: It will decide the type of elements array will accept. For example, If we want to store integer values, the Data Type will be declared as an int, to store Float values the Data Type is float
- Array_Name: This is the name you want to give it to an array. For example, students, age, marks, emp
Similarly, you can declare the remaining type of arrays in Java as follows:
Create a Java Array
In order to create an array in Java, we have to use the New operator
Array_Size: Number of elements an array can hold or store. For example, Array_Size =10, then the array will hold 10 values.
If you already initialized an array in java then
For Example, int[] Student_Marks = new int;
- We used int as the data type to declare an array. So, the above array will accept only integers. If we try to add float values, then it will throw an error.
- Student_Age is the array name
- The size of an Array is ten. It means Student_Marks array will only accept ten integer values.
- If we try to store more than ten, then it throws an error.
- We can store less than 10. For Example, If we store three integer values, then the remaining two values will be initialized to the default value (Which is 0).
Java Array Initialization
There are multiple ways to initialize the array in Java Programming language
First Approach
Declaring and Creating an Array in Java Programming
int[] Student_Marks = new int;
Initializing Array elements in more traditional way
Second Approach to create an Array in Java
In this approach, We initialize the array at the declaration time only
int[] anIntegerArray = {15, 25, 35, 45, 55}
Here, We did not mention the array size. However, the Javac is intelligent enough to determine the array size by checking the number of elements.
Third Approach
Although this approach works without any error, this is not the preferred way to initialize a java array
int Employees = {1, 2, 3, 4, 5}
Fourth Approach
The above 3 methods are good to store a small number of items into an array. What if we want to store 50, 100, or more values. It will be a torture to add all of them using any of the approaches mentioned above. To resolve this, we can use the loop concept to store data into a java array here:
TIP: In order to store the elements in an array, We can use For loop, While Loop and Do While Loop
Fifth Approach of creating an array in Java
int[] anIntegerArray = new int;anIntegerArray = 10;anIntegerArray = 20;anIntegerArray = 30;
Here we declared an anIntegerArray array of size 5, but we only assigned three values to it. In this condition, the remaining values assigned to default values (0 in this case).
The above array will be:
Accessing Java Array Elements
We use the index position to access the items of an Array in Java. Using an index, we can access or alter/change array item. Index value starts at 0 and ends at n-1, where n is the size or length of an array.
For example, if an array stores ten elements, the index starts at 0 and ends at 9. To access or modify the first value, use Array_Name and to access or alter 10th value, use Array_Name. Let us see the example for better knowledge of accessing Java array elements:
Объявление массива в Java
Теперь, когда мы знаем типы массивов, которые мы можем использовать, давайте узнаем, как объявить новый массив в Java. Вот основной синтаксис объявления массива.
- dataType: это может быть любой объект Java или примитивный тип данных (например, int, byte, char, boolean и т. д.)
- arrayName: это идентификатор, поэтому вы можете получить доступ к массиву
Давайте создадим простой массив на Java, чтобы понять синтаксис. Сначала объявите тип переменной, используя квадратные скобки [].
Теперь у нас есть переменная, содержащая массив строк. Мы можем вставлять значения, используя литерал массива. Мы помещаем наши значения в список, разделенный запятыми, который заключен в фигурные скобки {}.
Немного иначе выглядит создание массива целых чисел.
Как мы узнали, массивы содержат фиксированное количество элементов. Мы должны определить количество элементов, которые будет содержать наш массив для размещения памяти. Вот основной синтаксис выделения памяти.
Выше в массиве может храниться 5 элементов, что означает, что длина массива равна 5. В качестве другого примера предположим, что мы хотим сохранить имена 50 человек. Создаем массив строкового типа. В приведенном ниже массиве может храниться не более 50 элементов.
Есть и другие способы объявить массив в Java. Вот три варианта:
В первых двух случаях мы добавляем элементы в контейнер массива вручную. В третьем случае мы добавили элементы при объявлении массива.
Примечание. В официальной документации Java рекомендуется объявлять массив, используя:
типы массивов в Java
В Java есть 2 типа массивов:
- Одномерный массив — он содержит только 1 строку и 1 столбец. Все приведенные выше примеры относятся к одномерному массиву
- Многомерный массив — содержит несколько строк и несколько столбцов. Другими словами, это массив массивов, в которых все строки имеют одинаковые Число столбцов. Например: 2 * 2 матрица
- Неровный массив — каждая строка содержит разное количество столбцов.
Многомерные массивы в java
Многомерные массивы могут иметь несколько строк и столбцов. Индекс в первом [] представляет строки, а второй [] представляет столбцы.
Например: int [] [] a = new int
Это означает, что массив содержит 2 строки и 3 столбца. Ниже приведено схематическое изображение многомерного массива.
Пример создания многомерных массивов строк
В приведенном ниже примере показано, как создавать, объявлять и получать доступ к элементам многомерного массива. Здесь мы получаем прямой доступ элементы массива используя индекс строки и столбца.
public class ArrayMulti {
public static void main(String[] args) {
String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
System.out.println(arrNames + " " + arrNames);
System.out.println(arrNames + " " + arrNames);
}
}
Output: John Jacob Thomas Martin
Пример двумерного массива целых чисел
Здесь мы создаем двумерный массив целых чисел, состоящий из 2 строк и 2 столбцов. Мы присваиваем значения этим элементам массива внутри цикла for. Первый цикл for обозначает строки, а второй цикл for — столбцы.
public class ArrayMulti {
public static void main(String[] args) {
//Declare and create multidimensional array
int[][] arrnum = new int;
for(int i=0;i<2;i++) {
for(int j=0;j<3;j++) {
//Assign values to array elements
arrnum = i+1;
System.out.print(arrnum + " ");
}
System.out.println();
}
}
}
Output: 1 1 1 2 2 2
Зубчатые массивы в Java
Неровный массив — это также двумерный массив, имеющий другое количество столбцов. Другими словами, каждый строка имеет другое количество столбцов. Инициализация массива с зазубринами отличается от инициализации обычного 2D-массива.
Инициализация массива с зазубринами
При создании массива мы указываем количество строк. В этом примере это 2. В следующих двух операторах для каждого массива строк мы указываем количество столбцов. Здесь в 2-й строке 1 столбца, а во 3-й строке 2 столбца.
int[][] arrnum = new int[]; arrnum = new int; arrnum = new int;
Пример зазубренного массива путем присвоения значений в цикле for
public class JaggedArray {
public static void main(String[] args) {
int[][] arrnum = new int[];
arrnum = new int;
arrnum = new int;
int val=1;
//Assign values
for(int i=0;i<arrnum.length;i++) {
for(int j=0;j<arrnum.length;j++) {
arrnum = val;
}
}
//Print the values
for(int i=0;i<arrnum.length;i++)
{
for(int j=0;j<arrnum.length;j++)
{
System.out.print(arrnum + " ");
}
System.out.println();
}
}
}
Output: 1 1 1 1 1 1 1
Пример зазубренного массива с инициализацией значений во время создания массива
public class JaggedArray {
public static void main(String[] args) {
int[][] arr = {{4,5,6},{1,2},{7,9,8}};
for(int i=0;i<3;i++)
{
for(int j=0;j<arr.length;j++) {
System.out.print(arr + " ");
}
System.out.println();
}
}
}
Output: 4 5 6 1 2 7 9 8
Массивы Java и ArrayList
Массив Java – это базовая структура данных, предоставляемая языком. В отличие от этого, ArrayList является реализацией интерфейса List , поддерживаемого массивом, и предоставляется в рамках коллекций Java.
2.1. Доступ к элементам и их изменение
Мы можем получить доступ к элементам массива и изменить их, используя обозначения в квадратных скобках:
System.out.println(anArray); anArray = 4;
С другой стороны, ArrayList имеет набор методов для доступа и изменения элементов:
int n = anArrayList.get(1); anArrayList.set(1, 4);
2.2. Фиксированный и динамический размер
Массив и ArrayList выделяют память кучи аналогичным образом, но разница заключается в том, что массив имеет фиксированный размер, в то время как размер ArrayList динамически увеличивается.
Поскольку массив Java имеет фиксированный размер, нам необходимо указать его размер при создании экземпляра. Невозможно увеличить размер массива после его создания. Вместо этого нам нужно создать новый массив с измененным размером и скопировать все элементы из предыдущего массива.
ArrayList — это реализация изменяемого размера массива интерфейса List , то есть ArrayList динамически растет по мере добавления в него элементов. Когда количество текущих элементов (включая новый элемент, добавляемый в ArrayList ), превышает максимальный размер базового массива, то ArrayList увеличивает размер базового массива.
Стратегия роста базового массива зависит от реализации ArrayList . Однако, поскольку размер базового массива не может быть увеличен динамически, создается новый массив, и старые элементы массива копируются в новый массив.
Операция добавления имеет постоянную амортизированную временную стоимость. Другими словами, добавление n элементов в ArrayList требует O(n) времени.
2.3. Типы элементов
Массив может содержать как примитивные, так и непримитивные типы данных, в зависимости от определения массива. Однако an ArrayList может содержать только непримитивные типы данных .
Когда мы вставляем элементы с примитивными типами данных в ArrayList , компилятор Java автоматически преобразует примитивный тип данных в соответствующий класс-оболочку объекта.
Теперь давайте рассмотрим, как добавлять и вставлять элементы в массивы Java и ArrayList .
Как объявить двумерный массив в Java?
Вместо одной скобки вы будете использовать две, например, int [] [] — двумерный целочисленный массив. Определяется это следующим образом:
int[][] multiples = new int; // 2D integer array 4 строки и 2 столбца String[][] cities = new String; // 2D String array 3 строки и 3 столбца
Кстати, когда вы изначально объявляете, вы должны помнить, что нужно указать первое измерение, например, следующее объявление является неверным:
int[][] wrong = new int[][]; // not OK, you must specify 1st dimension int[][] right = new int[];
Выражение выдаст ошибку «переменная должна предоставить либо выражения измерения, либо инициализатор массива» во время компиляции. С другой стороны, при заполнении, второе измерение является необязательным и даже если вы не укажете, компилятор не будет ругаться, как показано ниже:
String[][] myArray = new String[]; // OK String[][] yourArray = new String; // OK
Потому что двумерный массив не что иное, как массив из одномерных массивов, из-за этого, вы также можете создать двумерный, где отдельные одномерные имеет разную длину, как показано в следующем примере.
class
TwoDimensionalArray { public static void main(String[] args) {
String[][] salutation = {
{"Mr. ", "Mrs. ", "Ms. "},
{"Kumar"}
};
// Mr. Kumar
System.out.println(salutation + salutation);
// Mrs. Kumar
System.out.println(salutation + salutation);
}
}
The output from this program is:
Mr. Kumar
Mrs. Kumar
В этом примере вы можете видеть объявление двумерного массива, но его первая строка имеет 3 элемента, а вторая строка имеет только один элемент.
Вы можете получить доступ к элементам, используя оба индекса или только один индекс. Например, salutation представляет единственную строку в Java, в то время как salutation представляет одномерный.
Пока мы только что объявили и создали массив, но не инициализировали. Здесь можно увидеть значения по умолчанию для различных типов.
boolean[][] booleans = new boolean;
System.out.println("booleans : " + booleans);
byte[][] bytes = new byte;
System.out.println("bytes : " + bytes);
char[][] chars = new char;
System.out.println("chars : " + (int)chars);
short[][] shorts = new short;
System.out.println("short : " + shorts);
int[][] ints = new int;
System.out.println("ints : " + ints);
long[][] longs = new long;
System.out.println("longs : " + longs);
float[][] floats = new float;
System.out.println("floats : " + floats);
double[][] doubles = new double;
System.out.println("doubles : " + doubles);
Object[][] objects = new Object;
System.out.println("objects : " + objects);
Output booleans : false bytes : 0 chars : 0 short : 0 ints : 0 longs : 0 floats : 0.0 doubles : 0.0 objects : null
Массив символов немного сложнее, потому что, если вы печатаете 0 как символ, он напечатает нулевой символ, и поэтому я использовал его целочисленное значение, приведя к int.
Итерация
Как перебрать все элементы массива, используя цикл Java for:
String[] stringArray = new String;
for(int i=0; i < stringArray.length; i++) {
stringArray = "String no " + i;
}
for(int i=0; i < stringArray.length; i++) {
System.out.println( stringArray );
}
В этом примере:
- Сначала создается массив ссылок String. Когда впервые создаете массив ссылок на объекты, каждая из ячеек в массиве указывает на ноль, а не на объект.
- Первый из двух циклов for выполняет итерацию по массиву String, создает строку и делает ссылку на ячейку этой строкой.
- Второй из двух циклов for перебирает массив String и печатает все строки, на которые ссылаются ячейки.
Если бы это был массив int (примитивные значения), он мог бы выглядеть так:
int[] intArray = new int;
for(int i=0; i < intArray.length; i++) {
intArray = i;
}
for(int i=0; i < intArray.length; i++) {
System.out.println( intArray );
}
Переменная i инициализируется равной 0 и работает до длины массива минус 1. В этом случае i принимает значения от 0 до 9, каждый раз повторяя код внутри цикла for один раз, и для каждой итерации i имеет другое значение.
Как перебрать массив с помощью цикла «for-each» в Java. Вот как это выглядит:
int[] intArray = new int;
for(int theInt : intArray) {
System.out.println(theInt);
}
Цикл for-each дает вам доступ к каждому элементу в массиве по одному, но не информацию об индексе каждого элемента. Есть доступ только к значению. Изменить значение элемента в этой позиции невозможно. Если это нужно, используйте обычный цикл for, как показано ранее.
Цикл for-each также работает с массивами объектов. Вот пример, как выполнить итерацию массива объектов String:
String[] stringArray = {"one", "two", "three"};
for(String theString : stringArray) {
System.out.println(theString);
}
Параллельные операции над массивами
Последнее обновление: 30.04.2018
В JDK 8 к классу Arrays было добавлено ряд методов, которые позволяют в параллельном режиме совершать обработку элементов массива.
И хотя данные методы формально не входят в Stream API, но реализуют схожую функциональность, что и параллельные потоки:
-
parallelPrefix(): вычисляет некоторое значение для элементов массива (например, сумму элементов)
-
parallelSetAll(): устанавливает элементы массива с помощью лямбда-выражения
-
parallelSort(): сортирует массив
Используем метод для установки элементов массива:
import java.util.Arrays;
public class Program {
public static void main(String[] args) {
int[] numbers = initializeArray(6);
for(int i: numbers)
System.out.println(i);
}
public static int[] initializeArray(int size) {
int[] values = new int;
Arrays.parallelSetAll(values, i -> i*10);
return values;
}
}
В метод передается два параметра: изменяемый массив и функция, которая устанавливает элементы массива. Эта
функция перебирает все элементы и в качестве параметра получает индекс текущего перебираемого элемента. Выражение означает,
что по каждому индексу в массиве будет хранится число, равное i * 10. В итоге мы получим следующий вывод:
0 10 20 30 40 50
Рассмотрим более сложный пример. Пусть у нас есть следующий класс Phone:
class Phone{
private String name;
private int price;
public Phone(String name, int price){
this.name=name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String val) {
this.name=val;
}
public int getPrice() {
return price;
}
public void setPrice(int val) {
this.price=val;
}
}
Теперь произведем манипуляции с массивом объектов Phone:
Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000),
new Phone("Pixel 2", 45000),
new Phone("Samsung Galaxy S9", 40000),
new Phone("Nokia 9", 32000)};
Arrays.parallelSetAll(phones, i -> {
phones.setPrice(phones.getPrice()-10000);
return phones;
});
for(Phone p: phones)
System.out.printf("%s - %d \n", p.getName(), p.getPrice());
Теперь лямбда-выражение в методе представляет блок кода. И так как лямбда-выражение должно возвращать объект, то нам надо явным образом использовать
оператор return. В этом лямбда-выражении опять же функция получает индексы перебираемых элементов, и по этим индексам мы можем обратиться
к элементам массива и их изменить. Конкретно в данном случае происходит уменьшение цены смартфонов на 10000 единиц. В итоге мы получим следующий
консольный вывод:
iPhone 8 - 44000 Pixel 2 - 35000 Samsung Galaxy S9 - 30000 Nokia 9 - 22000
Сортировка
Отсортируем массив чисел в параллельном режиме:
int[] nums = {30, -4, 5, 29, 7, -8};
Arrays.parallelSort(nums);
for(int i: nums)
System.out.println(i);
Метод в качестве параметра принимает массив и сортирует его по возрастанию:
-8 -4 5 7 29 30
Если же нам надо как-то по-другому отсортировать объекты, например, по модулю числа, или у нас более сложные объекты, то мы можем создать свой компаратор и передать его в качестве второго параметра в
. Например, возьмем выше определенный класс Phone и создадим для него компаратор:
import java.util.Arrays;
import java.util.Comparator;
public class Program {
public static void main(String[] args) {
Phone[] phones = new Phone[]{new Phone("iPhone 8", 54000),
new Phone("Pixel 2", 45000),
new Phone("Samsung Galaxy S9", 40000),
new Phone("Nokia 9", 32000)};
Arrays.parallelSort(phones,new PhoneComparator());
for(Phone p: phones)
System.out.println(p.getName());
}
}
class PhoneComparator implements Comparator<Phone>{
public int compare(Phone a, Phone b){
return a.getName().toUpperCase().compareTo(b.getName().toUpperCase());
}
}
Метод parallelPrefix
Метод походит для тех случаев, когда надо получить элемент массива или объект того же типа, что и элементы массива, который обладает некоторыми признаками.
Например, в массиве чисел это может быть максимальное, минимальное значения и т.д. Например, найдем произведение чисел:
int[] numbers = {1, 2, 3, 4, 5, 6};
Arrays.parallelPrefix(numbers, (x, y) -> x * y);
for(int i: numbers)
System.out.println(i);
Мы получим следующий результат:
1 2 6 24 120 720
То есть, как мы видим из консольного вывода, лямбда-выражение из , которое представляет бинарную функцию, получает два элемента и
выполняет над ними операцию. Результат операции сохраняется и передается в следующий вызов бинарной функции.
НазадВперед
