Массив — это структура данных, используемая для хранения набора переменных (элементов) одного типа. Элементы массива хранятся в непрерывной области памяти. Где к каждому элементу данных можно получить доступ по его порядковому номеру.
Массив в Java основан на индексах, первый элемент массива хранится в 0-м индексе, 2-й элемент хранится в 1-м индексе и так далее.
Зачем нам нужны массивы?
Массивы используются для хранения нескольких значений в одной переменной вместо объявления отдельных переменных для каждого значения.
Объявление массивов
Чтобы объявить массив, определите тип переменной с помощью квадратных скобок.
Syntax:
dataType[] arrayName;
Example:
int[] arr;
OR // String[] cars;
int arr[];
Creating an array:
int[] arr = new int[10]; // To define the array's capacity, use the keyword new
Доступ к элементам массива
Вы можете получить доступ к элементу массива, обратившись к номеру index.
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars[0]);
// Output Volvo
Примечание. Индексы массива начинаются с 0: [0] — это первый элемент. [1] — второй элемент и т. д.
Изменить элемент массива
Чтобы изменить значение определенного элемента, обратитесь к номеру индекса:
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
cars[0] = "Opel";
System.out.println(cars[0]);
// Now output is Opel instead of Volvo
Длина массива
Вы можете получить доступ к длине массива (количеству элементов, которые он хранит) через его свойство length. В C/C++ нам нужно использовать оператор sizeof.
Чтобы узнать, сколько элементов в массиве, используйте свойство length:
public class Program {
public static void main(String[] args) {
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars.length);
}
}
// Output: 4
// Note: Array index starts from 0.
/* Method 1:
int[] arr = new int[10];
int arrayLength = arr.length;
System.out.println("Array Length is: " + arrayLength);
Method 2:
String[] city = {
"Delhi",
"Bhubaneswar",
"Mumbai",
"Bangalore",
"Kolkata",
"Hyderabad",
};
int arrayLength = city.length;
System.out.println("The size of the array is: " + arrayLength); */
/* Output:
Method 1: 10
Method 2: 6 */
Цикл for чаще всего используется при работе с массивами, поскольку мы можем использовать длину массива, чтобы определить, сколько раз выполнять цикл.
Пример. Вычисление суммы всех элементов массива с помощью цикла for.
public class Pprogram {
public static void main(String[] args) {
int [] myArr = {6, 42, 3, 7};
int sum = 0;
for(int x=0; x<myArr.length; x++) {
sum += myArr[x];
}
System.out.println(sum);
}
}
// Output: 58
В приведенном выше коде мы объявили переменную с именем sum для хранения результата и присвоили ей значение 0. Затем мы использовали цикл for для перебора массива, добавляя значение каждого элемента к переменной.
Условие цикла for — x‹myArr.length, так как индекс последнего элемента — myArr.length-1.
Улучшенный цикл for
Усовершенствованный цикл for (цикл for each) используется для обхода элементов в массивах. Преимущества в том, что это исключает возможность ошибок и облегчает чтение кода.
public class Program {
public static void main(String[] args) {
int[] primes = {2, 3, 5, 7};
for(int t: primes) { // Syntax: for(dataType item : array)
System.out.println(t);
}
}
}
/* Output:
2
3
5
7 */
Расширенный цикл for объявляет переменную типа, совместимого с элементами массива, к которым осуществляется доступ. Переменная будет доступна в блоке for, и ее значение будет таким же, как у текущего элемента массива.
Таким образом, на каждой итерации цикла переменная t будет равна соответствующему элементу массива.
Типы массивов в java.
Существует два типа массива.
- Одномерный массив
- Многомерный массив
Одномерный массив
Одномерный массив или одномерный массив можно визуализировать как одну строку или столбец элементов массива, которые представлены именем переменной и доступ к элементам которых осуществляется с помощью значений индекса. Одномерный массив в java должен иметь дело только с одним параметром.
Например, счет серии футбольных матчей может храниться в одномерном массиве.
Объявление одномерного массива
Общая форма:
data-type var-name[];
OR
data-type[] var-name;
OR
data-type []var-name;
Объявление массива состоит из двух компонентов:
- тип данных: тип данных определяет тип данных каждого элемента, присутствующего в массиве, например char, int, float, объекты и т. д.
- имя-переменной: это имя ссылочной переменной, которая указывает на объект массива, хранящийся в куче памяти.
[ ] называется индексом.
Построение одномерного массива в Java
В основном существует два способа создания массива в Java:
- Мы можем объявить и сохранить значения непосредственно во время объявления:
int marks[ ] = { 90, 97, 95, 99, 100 };
Здесь JVM (виртуальная машина Java, которая управляет кодом Java, преобразует байт-код Java в машинный язык) назначит пять непрерывных ячеек памяти для хранения значений, присвоенных массиву.
2. Второй способ создания массива — сначала объявить массив, а затем выделить память с помощью ключевого слова new:
var-name = new type[size]; // int[] Number = new int[10];
Здесь size определяет максимальное количество элементов, которые могут храниться в массиве. Чтобы выделить память с помощью new, мы должны указать тип и количество элементов в массиве. JVM выделила места в памяти для хранения 10 целых чисел, но мы еще не сохранили фактические элементы в массиве. Итак, далее мы рассмотрим, как элементы сохраняются в памяти.
Представление памяти после построения
new int[10] инициализирует и создает объект, на который ссылается число, и выделяет память объекту в сегменте кучи.
Инициализация одномерного массива
public class AssignValues {
public static void main(String args[]) {
int number[]; // array declared
number = new int[10]; // allocating memory, initialization
number[0] = 11;
number[1] = 22;
number[2] = 33;
number[3] = 44;
number[4] = 55;
number[5] = 66;
number[6] = 77;
number[7] = 88;
number[8] = 99;
number[9] = 100;
}
}
Примечание.
- Поскольку мы выбрали тип данных int, мы можем добавлять в массив только целочисленные значения. Итак, тип переменной зависит от типа данных массива.
- Размер массива зависит от того, сколько значений мы предоставляем во время инициализации.
- Размер одномерных массивов нельзя изменить после их создания.
Общий синтаксис: одномерный массив
data_type[] var_name = new data_type[];
OR
data_type var_name[] = {}; // curly braces encloses specialized set of values
Например:
public class Example {
public static void main(String args[]) {
int arr[] = { 1, 5, 10, 15, 20 }; // initializing array
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i] + " "); // printing array elements
}
}
}
// Output : 1 5 10 15 20
Многомерные массивы
Многомерные массивы организованы как массив массивов. Вы можете рассматривать его как один контейнер, в котором хранится несколько контейнеров. Каждый элемент многомерного массива сам является массивом.
Представление элементов в строках и столбцах. Таким образом, вы можете получить общее количество элементов в многомерном массиве, умножив размер строки на размер столбца. Итак, если у вас есть двумерный массив 3×4, то общее количество элементов в этом массиве = 3×4 = 12.
Например,
int[][] a = new int[3][4];
Здесь мы создали многомерный массив с именем a. Это двумерный массив, который может содержать не более 12 элементов,
Примеры:
Two dimensional array: int[][] twoD_arr = new int[10][20]; // (or) int a[][] = new int[3][3]; Three dimensional array: int[][][] threeD_arr = new int[10][20][30]; // (or) int a[][][] = new int[3][3][3];
Двумерный массив
2D-массив можно определить как массив массивов. Двумерный массив организован как матрицы, которые можно представить как набор строк и столбцов.
Объявление и инициализация двумерного массива
В программировании на Java двумерный массив может быть объявлен и инициализирован несколькими способами.
int a[][]= new int[][] {{1,2,3}, {4,5,6}, {7,8,9}};
(or)
int a[][]= {{15,27,36}, {41,52,64}, {79,87,93}};
(or)
int a[][]= new int[3][3];
Например :
В Java существуют различные методы для двумерных массивов.
- Использование стандартного метода
- Использование цикла For
- Использование сканера
- Использование строки
Стандартный метод
class TwodimensionalStandard
{
public static void main(String args[])
{
int[][] a={{10,20},{30,40}};//declaration and initialization
System.out.println("Two dimensional array elements are");
System.out.println(a[0][0]);
System.out.println(a[0][1]);
System.out.println(a[1][0]);
System.out.println(a[1][1]);
}
}
/* Output:
Two dimensional array elements are
10
20
30
40 */
Метод цикла For
class TwodimensionalLoop
{
public static void main(String args[])
{
int[][] a={{10,20},{30,40},{50,60}};//declaration and initialization
System.out.println("Two dimensional array elements are");
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 2; j++)
{
System.out.println(a[i][j]);
}
}
}
}
/* Output:
Two dimensional array elements are
10
20
30
40
50
60 */
Метод сканирования
import java.util.*;
class TwoDimensionalScanner
{
public static void main(String args[])
{
Scanner sc=new Scanner(System.in);
System.out.println("Enter Row length of an array : ");
int row=sc.nextInt();
System.out.println("Enter column length of an array : ");
int column=sc.nextInt();
int a[][]=new int[row][column];//declaration
System.out.print("Enter " + row*column + " Elements to Store in Array :\n");
for (int i = 0; i < row; i++)
{
for(int j = 0; j < column; j++)
{
a[i][j] = sc.nextInt();
}
}
System.out.print("Elements in Array are :\n");
for (int i = 0; i < row; i++)
{
for(int j = 0; j < column; j++)
{
System.out.println("Row ["+i+"]: Column ["+j+"] :"+a[i][j]);
}
}
}
}
/* Output:
Enter Row length of an array :
2
Enter column length of an array :
3
Enter 6 Elements to Store in Array :
1
2
3
4
5
6
Elements in Array are :
Row [0]: Column [0] :1
Row [0]: Column [1] :2
Row [0]: Column [2] :3
Row [1]: Column [0] :4
Row [1]: Column [1] :5
Row [1]: Column [2] :6 */
Строковый метод
class TwoDimensionalString
{
public static void main(String[] args)
{
String[][] str = new String[][]{{"one", "two"}, {"three", "four"},{"five","six"}};
System.out.println("Two dimensional string array elements are :\n");
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 2; j++)
{
System.out.println("str["+i+"]["+j+"]:"+str[i][j]);
}
}
}
}
/* Output:
Two dimensional string array elements are :
str[0][0]:one
str[0][1]:two
str[1][0]:three
str[1][1]:four
str[2][0]:five
str[2][1]:six */
class MultidimensionalArray {
public static void main(String[] args) {
// create a 2d array
int[][] a = {
{1, 2, 3},
{4, 5, 6, 9},
{7},
};
// calculate the length of each row
System.out.println("Length of row 1: " + a[0].length);
System.out.println("Length of row 2: " + a[1].length);
System.out.println("Length of row 3: " + a[2].length);
}
}
// Here, we are using the length attribute to calculate the length of each row.
/* Output:
Length of row 1: 3
Length of row 2: 4
Length of row 3: 1 */
Трехмерный массив
Массив с тремя индексами (индексами) называется трехмерным массивом в Java.
Другими словами, трехмерный массив — это набор одного или нескольких двумерных массивов, все из которых имеют общее имя.
Трехмерный массив Java полезен, когда мы хотим обработать группу элементов, принадлежащих другой группе. Например, предположим, что в колледже есть три отделения: электроники, компьютерных наук и информационных технологий.
Мы можем представить результаты экзаменов, полученные тремя студентами каждого факультета по трем различным предметам, следующим образом:
Electronics department:
student1 scores: 75, 87, 69
student2 scores: 90, 87, 85
student3 scores: 56, 67, 76
Computer Science department:
student1 scores: 78, 67, 75
student2 scores: 87, 98, 76
student3 scores: 67, 56, 65
Information Technology department:
student1 scores: 72, 63, 72
student2 scores: 82, 91, 71
student3 scores: 64, 56, 66
The syntax below declares a three-dimensional array of variable scores, creates an array, and assigns its reference to scores:
// int[ ][ ][ ] scores = new int[3][3][3];
We can also use the shorthand notation to create and initialize the array as follows:
int[ ][ ][ ] scores = {
{{75, 87, 69}, {90, 87, 85},{56, 67, 76}},
{{78, 67, 75}, {87, 98, 76}, {67, 56, 66}},
{{72, 63, 72}, {82, 91, 71}, {64, 56, 66}}
};
Ключевые моменты:
а) многомерный массив в java на самом деле является массивом, в котором каждый элемент представляет другой массив.
б) Разница между трехмерным массивом и двумерным массивом заключается в том, что трехмерный массив состоит из массива двумерных массивов, тогда как двумерный массив состоит из массива одномерных массивов.
c) Три цикла for (вложенный цикл) используются для доступа к каждому элементу в таблицах.
г) Первый цикл for используется для выбора каждой таблицы.
e) Второй цикл for используется для выбора каждой строки выбранной таблицы.
f) Третий цикл for используется для доступа к каждому элементу (значению) в выбранной строке и таблице.
Трехмерный (3D-массив) пример
Создайте трехмерный массив, состоящий из оценок учащихся по отделам. Есть три отдела: электроники, CS и IT.
На каждом отделении 3 студента, и каждый студент имеет баллы по 3 предметам. Мы посчитаем общие полученные оценки и их процент для каждого ученика.
public class ThreeDArray {
public static void main(String[] args)
{
String[ ] department = {"Electronics", "CS", "IT"};
int dept, st, sc, total = 0;
double perc = 0;
// Take the scores of students in a 3D array.
int[ ][ ][ ] scores = {
{{75, 87, 69}, {90, 87, 85},{56, 67, 76}},
{{78, 67, 75}, {87, 98, 76}, {67, 56, 66}},
{{72, 63, 72}, {82, 91, 71}, {64, 56, 66}}
};
// Display the scores of students from 3D array.
for(dept = 0; dept < 3; dept++)
{
for(int i = 0; i < 3; i++)
{
System.out.println("Department " +department[i]+ ": ");
for(st = 0; st < 3; st++)
{
System.out.println("Student" +(st + 1)+ " scores: ");
for(sc = 0; sc < 3; sc++)
{
System.out.print(scores[dept][st][sc]+ " ");
total += scores[dept][st][sc];
perc = (double)total/3;
}
System.out.println("\nTotal scores: " +total); // Displaying total marks of student.
System.out.println("Percentage: " +perc); // Displaying percentage.
total = 0; // reset total to zero.
}
System.out.println();
}
break;
}
}
}
/* Output:
Department Electronics:
Student1 scores: 75 87 69
Total scores: 231
Percentage: 77.0
Student2 scores: 90 87 85
Total scores: 262
Percentage: 87.33333333333333
Student3 scores: 56 67 76
Total scores: 199
Percentage: 66.33333333333333
Department CS:
Student1 scores: 75 87 69
Total scores: 231
Percentage: 77.0
Student2 scores: 90 87 85
Total scores: 262
Percentage: 87.33333333333333
Student3 scores: 56 67 76
Total scores: 199
Percentage: 66.33333333333333
Department IT:
Student1 scores: 75 87 69
Total scores: 231
Percentage: 77.0
Student2 scores: 90 87 85
Total scores: 262
Percentage: 87.33333333333333
Student3 scores: 56 67 76
Total scores: 199
Percentage: 66.33333333333333 */
Массив строк
Массив строк — это массив фиксированного числа строковых значений. Строка — это последовательность символов. Как правило, строка является неизменяемым объектом, что означает, что значение строки не может быть изменено. Строковый массив работает аналогично другим типам данных массивов.
Ключевые моменты о массиве строк:
- Это объект массива.
- Его можно объявить двумя способами; с указанием размера или без указания размера.
- Его можно инициализировать либо во время объявления, либо путем заполнения значений после объявления.
- Элементы могут быть добавлены в массив строк после его объявления.
- Массив строк можно повторять с помощью цикла for.
- Операция поиска и сортировки может выполняться в массиве строк.
Декларация:
Строковый массив может быть объявлен следующим образом:
String[] stringArray1 //Declaration of the String Array without specifying the size String[] stringArray2 = new String[2]; //Declarartion by specifying the size
Инициализация:
String[] strAr1=new String[] {"Ani", "Sam", "Joe"}; //inline initialization
2. String[] strAr2 = {"Ani", "Sam", " Joe"};
3. String[] strAr3= new String[3]; //Initialization after declaration with specific size
strAr3[0]= "Ani";
strAr3[1]= "Sam";
strAr3[2]= "Joe";
Добавление элементов в массив строк
Мы можем легко добавлять элементы в массив строк, как и другие типы данных. Это можно сделать с помощью следующих трех методов:
- Использование предварительного выделения массива
- Использование списка массивов
- Создав новый массив
- Предварительное выделение массива
В этом методе у нас уже есть массив большего размера.
Например, если нам нужно сохранить 10 элементов, мы создадим массив размером 20. Это самый простой способ расширить элементы массива.
// Java Program to add elements in a pre-allocated Array
import java.util.Arrays;
public class StringArrayDemo {
public static void main(String[] args) {
String[] sa = new String[7]; // Creating a new Array of Size 7
sa[0] = "A"; // Adding Array elements
sa[1] = "B";
sa[2] = "C";
sa[3] = "D";
sa[4] = "E";
System.out.println("Original Array Elements:" + Arrays.toString(sa));
int numberOfItems = 5;
String newItem = "F"; // Expanding Array Elements Later
String newItem2 ="G";
sa[numberOfItems++] = newItem;
sa[numberOfItems++] = newItem2;
System.out.println("Array after adding two elements:" +
Arrays.toString(sa));
}
}
/* Output:
Original Array Elements:[A, B, C, D, E, null, null]
Array after adding two elements:[A, B, C, D, E, F, G] */
В этом примере мы добавили два элемента в предварительно выделенный массив.
2.Список массивов
Список массивов — это структура данных в структуре коллекций Java. Мы можем легко добавлять элементы в массив строк, используя список массивов в качестве промежуточной структуры данных. Класс Java ArrayList использует динамический массив для хранения элементов. Это похоже на массив, но без ограничений по размеру. Мы можем добавлять или удалять элементы в любое время. Он находится в пакете java.util. Это как вектор в C++.
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class StringArrayDemo1 {
public static void main(String[] args)
{
// Defining a String Array
String sa[] = { "A", "B", "C", "D", "E", "F" };
//
System.out.println("Initial Array:\n"
+ Arrays.toString(sa));
String ne = "G"; // Define new element to add
List<String>l = new ArrayList<String>(
Arrays.asList(sa)); // Convert Array to ArrayList
l.add(ne); // Add new element in ArrayList l
sa = l.toArray(sa); // Revert Conversion from ArrayList to Array
// printing the new Array
System.out.println("Array with added Value: \n"
+ Arrays.toString(sa)) ;
}
}
/* Output:
Initial Array:
[A, B, C, D, E, F]
Array with added value:
[A, B, C, D, E, F, G] */
3. Создание нового массива
В этом методе мы создадим новый массив большего размера, чем исходный массив, и разместим в нем элементы. Мы скопируем все элементы во вновь добавленный массив.
// Java Program to add elements in a String Array by creating a new Array
import java.util.Arrays;
public class StringArrayDemo2 {
public static void main(String[] args) {
//Declaring Initial Array
String[] sa = {"A", "B", "C" };
// Printing the Original Array
System.out.println("Initial Array: " + Arrays.toString(sa));
int length_Var = sa.length; //Defining the array length variable
String newElement = "D"; // Defining new element to add
//define new array with extended length
String[] newArray = new String[ length_Var + 1 ];
//Adding all the elements to initial Array
for (int i=0; i <sa.length; i++)
{
newArray[i] = sa [i];
}
//Specifying the position of the added elements ( Last)
newArray[newArray.length- 1] = newElement;
//make it original and print
sa = newArray;
System.out.println("updated Array: " + Arrays.toString(sa));
}
}
/* Output:
Initial Array: [A, B, C]
updated Array: [A, B, C, D] */
Анонимный массив
Массив в Java без имени называется анонимным массивом. Это массив только для мгновенного создания и использования. Используя анонимный массив, мы можем передать массив с пользовательскими значениями без ссылочной переменной.
Свойства анонимных массивов:
- Мы можем создать массив без имени. Такие типы безымянных массивов называются анонимными массивами.
- Основная цель анонимного массива - просто мгновенное использование (только для одноразового использования).
- Анонимный массив передается в качестве аргумента метода.
Примечание. При создании анонимного массива не указывайте размер в []. Количество значений, проходящих внутри {}, станет размером.
Синтаксис:
new <data type>[]{<list of values with comma separator>};
Примеры:
// anonymous int array
new int[] { 1, 2, 3, 4};
// anonymous char array
new char[] {'x', 'y', 'z'};
// anonymous String array
new String[] {"Geeks", "for", "Geeks"};
// anonymous multidimensional array
new int[][] { {10, 20}, {30, 40, 50} };
Реализация:
// Java program to illustrate the concept of anonymous array
class Test {
public static void main(String[] args)
{
// anonymous array
sum(new int[]{ 1, 2, 3 });
}
public static void sum(int[] a)
{
int total = 0;
// using for-each loop
for (int i : a)
total = total + i;
System.out.println("The sum is: " + total);
}
}
/* Output:
The sum is: 6 */
В приведенном выше примере просто для вызова метода суммы нам потребовался массив, но после реализации метода суммы мы больше не используем массив. Следовательно, для этого одноразового требования анонимный массив является лучшим выбором.
