Массивы java

N-мерные массивы

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

Массивы бывают одномерными (векторы), двумерными (матрицы), трёхмерными и так далее. То есть можно создавать не просто массивы, но и массивы массивов, а также массивы массивов массивов и так далее.

Рассмотрим вариант с двумерным массивом. Остальные многомерные массивы создаются похоже.

Объявление двумерного массива

Чтобы создать двумерный массив, укажем его размеры в квадратных скобках:

Доступ к элементу подобного массива выглядит так:

Мы присвоили значение 2 элементу с индексами .

Для простоты представим двумерный массив в виде таблицы. Вот как выглядит наш массив (столбцы — это первый индекс в квадратных скобках, а строки — второй):

= 0	= 0	= 0
= 2	= 0	= 0
= 0	= 0	= 0
= 0	= 0	= 0

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

Массивы внутри массива в Java могут быть разной длины. Зададим двумерный массив, где размер третьего массива (по индексу второго) равен двум элементам, а размер всех остальных — трём:

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

Если мы объявляем двумерный массив так:

то размер каждого вложенного массива будет равен четырём элементам.

А теперь заменим массив под индексом 1 (длиной в четыре элемента) массивом из двух элементов:

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

Проверим, что размер массива под индексом 1 теперь равен двум элементам. Для этого используем цикл с выводом в консоль:

Для обхода элементов двумерного массива применяем уже два цикла:

Объявление, создание, инициализация

Перед тем как массив использовать, его нужно:

1. Объявить;
2. Создать;
3. Инициализировать.

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

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

Например такой код работать не будет: String a = 1;

Именно поэтому при объявлении массива сначала указывают тип данных который он будет принимать. Дальше идут [] (квадратные скобки) и имя переменной. Или имя переменной, квадратные скобки. Разницы не будет:

char nameOfArray[], int anotherName [], char [] nameOfArr, String [] p — это все правильные варианты для объявления массивов.

После того, как array был объявлен, его нужно создать. Дело в том, что в массив это объект. Объекты в java хранятся в памяти отдельно от переменных и примитивных типов. Для каждого объекта выделяется память в программе. В которой он будет находиться до того момента пока будет нужен. Чтобы указать программе что мы резервируем место для объекта нужно воспользоваться ключевым словом new.

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

Выше Вы можете видеть пример создания и инициализации массива. Сразу после знака равно (=) идет создание array с именем a. В квадратных скобках указана размерность (количество элементов).

Сразу после создания, в объект будут записаны значения по умолчанию. Для численного массива это ноль (0), для объекта — null, для boolean — false.

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

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

В квадратных скобках на примере выше указан индекс, а после знака равно — новое значение элемента по данному индексу.

Есть еще один способ инициализации:

Таким образом мы объединяем объявление, создание, инициализацию в одну строку. При таком подходе можно даже опустить new char[]:

Java traversing arrays

We often need to go through all elements of an array. We show two
common methods for traversing an array.

com/zetcode/TraversingArrays.java

package com.zetcode;

public class TraversingArrays {

    public static void main(String[] args) {

        String[] planets = { "Mercury", "Venus", "Mars", "Earth", "Jupiter",
            "Saturn", "Uranus", "Neptune", "Pluto" };

        for (int i=0; i < planets.length; i++) {

            System.out.println(planets);
        }

        for (String planet : planets) {

            System.out.println(planet);
        }
    }
}

An array of planet names is created. We use the for loop to print all the values.

for (int i=0; i < planets.length; i++) {

    System.out.println(planets);
}

In this loop, we utilize the fact that we can get the number of elements from the
array object. The number of elements is stored in the constant.

for (String planet : planets) {

    System.out.println(planet);
}

An enhanced for keyword can be used to make the code more compact when traversing
arrays or other collections. In each cycle, the planet variable is passed the next
value from the planets array.

Как распечатать массив

То же, что и с равняется метод, набор массива toString функция использует реализацию по умолчанию, предоставляемую Объект класс, который не очень полезен.

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

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

Класс Java Util предоставляет два статических метода, которые мы можем использовать:

• toString : не работает хорошо с зубчатыми массивами
• deepToString : поддерживает любую Объект на основе массивов, но не компилирует с примитивными аргументами массива

С другой стороны, Реализация Apache предлагает единый toString метод, который работает правильно в любом случае:

String arrayAsString = ArrayUtils.toString(array);

Java array methods

The class, available in the
package, is a helper class that contains methods for working with arrays.
These methods can be used for modifying, sorting, copying, or searching data.
These methods that we use are static methods of the class.
(Static methods are methods that can be called without creating an instance
of a class.)

com/zetcode/ArrayMethods.java

package com.zetcode;

import java.util.Arrays;

public class ArrayMethods {

    public static void main(String[] args) {

        int[] a = {5, 2, 4, 3, 1};

        Arrays.sort(a);

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

        Arrays.fill(a, 8);
        System.out.println(Arrays.toString(a));

        int[] b = Arrays.copyOf(a, 5);

        if (Arrays.equals(a, b)) {

            System.out.println("Arrays a, b are equal");
        } else {

            System.out.println("Arrays a, b are not equal");
        }
    }
}

In the code example, we will present five methods of the class.

import java.util.Arrays;

We will use the shorthand notation for the class.

int[] a = {5, 2, 4, 3, 1};

We have an array of five integers.

Arrays.sort(a);

The method sorts the integers in an ascending order.

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

The method returns a string representation
of the contents of the specified array.

Arrays.fill(a, 8);

The method assigns the specified integer value to
each element of the array.

int[] b = Arrays.copyOf(a, 5);

The method copies the specified number of elements
to a new array.

if (Arrays.equals(a, b)) {

    System.out.println("Arrays a, b are equal");
} else {

    System.out.println("Arrays a, b are not equal");
}

The method compares the two arrays. Two arrays are equal
if they contain the same elements in the same order.

$ java ArrayMethods.java


Arrays a, b are equal

This is the output.

Как инициализировать двумерный массив Java?

Ниже приводится пример инициализации двумерного массива Java:

int[][] a = {
      {1, 2, 3}, 
      {4, 5, 6, 9}, 
      {7}, 
};

Каждый компонент массива также представляет собой массив, и длина каждого ряда отличается:

Давайте напишем программу, чтобы это доказать:

class MultidimensionalArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, 2, 3}, 
            {4, 5, 6, 9}, 
            {7}, 
      };

      System.out.println("Длина ряда 1: " + a.length);
      System.out.println("Длина ряда 2: " + a.length);
      System.out.println("Длина ряда 3: " + a.length);
   }
}

При запуске этой программы мы получим:

Длина ряда 1: 3 Длина ряда 2: 4 Длина ряда 3: 1

Поскольку многомерный массив состоит из отдельных массивов (a, a and a), можно использовать метод length для определения длины каждого ряда длины двумерного массива Java.

Пример: вывод на экран всех элементов двумерного массива с помощью циклов:

class MultidimensionalArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, -2, 3}, 
            {-4, -5, 6, 9}, 
            {7}, 
      };

     for (int i = 0; i < a.length; ++i) {
        for(int j = 0; j < a.length; ++j) {
           System.out.println(a);
        }
     }
   }
}

Всегда лучше использовать цикл for…each, когда нужно пройти по элементам массива. Пример сортировки двумерного массива Java можно записать с помощью цикла for…each следующим образом:

class MultidimensionalArray {
   public static void main(String[] args) {

      int[][] a = {
            {1, -2, 3}, 
            {-4, -5, 6, 9}, 
            {7}, 
      };

     for (int[] innerArray: a) {
        for(int data: innerArray) {
           System.out.println(data);
        }
     }
   }
}

При запуске этой программы мы получим следующий результат заполнения двумерного массива Java:

1
-2
3
-4
-5
6
9
7

Как инициализировать многомерный массив Java?

Многомерный или трёхмерный массив инициализируется почти так же, как двухмерный:

// test — трёхмерный массив
int[][][] test = {
              {
               {1, -2, 3}, 
               {2, 3, 4}
              }, 
              { 
               {-4, -5, 6, 9}, 
               {1}, 
               {2, 3}
              } 
};

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

Пример: программа для вывода элементов трёхмерного массива с помощью циклов:

class ThreeArray {
   public static void main(String[] args) {

     // test – трёхмерный массив
     int[][][] test = {
              {
               {1, -2, 3}, 
               {2, 3, 4}
              }, 
              { 
               {-4, -5, 6, 9}, 
               {1}, 
               {2, 3}
              } 
     };

     // цикл for..each проходит по элементам трёхмерного массива
     for (int[][] array2D: test) {
        for (int[] array1D: array2D) {
           for(int item: array1D) {
              System.out.println(item);
           }
        }
     }
  }
}

При запуске программы вывода двумерного массива Java получаем следующий результат:

1
-2
3
2
3
4
-4
-5
6
9
1
2
3

Пожалуйста, опубликуйте ваши комментарии по текущей теме статьи. За комментарии, отклики, дизлайки, лайки, подписки огромное вам спасибо!

МКМихаил Кузнецовавтор-переводчик статьи «Java Multidimensional Arrays»

Java passing arrays to methods

In the next example, we pass an array to a method.

com/zetcode/PassingArrays.java

package com.zetcode;

import java.util.Arrays;

public class PassingArray {

    public static void main(String[] args) {

        int[] a = { 3, 4, 5, 6, 7 };
        int[] r = reverseArray(a);

        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(r));
    }

    private static int[] reverseArray(int[] b) {

        int[] c = new int;

        for (int i=b.length-1, j=0; i>=0; i--, j++) {

            c = b;
        }

        return c;
    }
}

The example reorders the elements of an array. For this task,
a method is created.

private static int[] reverseArray(int[] b) {

The method takes an array as a parameter
and returns an array. The method takes a copy of the passed array.

int[] c = new int;

Inside the body of the method, a new array is created; it will contain
the newly ordered elements.

for (int i=b.length-1, j=0; i>=0; i--, j++) {

    c = b;
}

In this for loop, we fill the new array with the elements
of the copied array. The elements are reversed.

return c;

The newly formed array is returned back to the caller.

System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(r));

We print the elements of the original and the reversed array.

$ java PassingArray.java

This is the output of the example.

Перебор коллекции в Java

Также для примера продемонстрируем, как происходит обработка коллекции типа Integer посредством ArrayList. Как известно, класс нам ArrayList нам нужен для реализации динамического массива, способного увеличиваться либо уменьшаться по мере необходимости. Для использования этого класса следует подключить пакет java.util.
Объявление класса ArrayList выглядит следующим образом:

class ArrayList<E>

Здесь E – это тип объектов, сохраняемых в массиве.
Класс Integer является классом-оберткой над типом int и представляет целочисленные значения. В нашем примере класс ArrayList, обрабатывающий объекты типа Integer, имеет следующий вид:

class ArrayList<Integer>

Теперь давайте посмотрим на использование расширенного цикла for (одна из возможных реализаций):

// подключаем пакет java.util
import java.util.*;
...

ArrayList<Integer> A = new ArrayList<Integer>(); // создаём коллекцию

// добавляем элементы в коллекцию
A.add(5);
A.add(9);
A.add(-20);
A.add(11);
A.add(7); // A = { 5, 9, -20, 11, 7 }

// находим сумму элементов коллекции
int sum = ;
    for (Integer i  A) // расширенный цикл for
        sum += i;

System.out.println("Sum = " + sum); // Sum = 12

Сортировка объектов

Показанный ранее пример Arrays.sort() работает только для массивов примитивных типов данных, которые имеют порядок:

• естественный;
• числовой;
• символьный в таблице ASCII (двоичное число, представляющее символ).

У объектов может не быть естественного порядка сортировки, поэтому вам нужно предоставить другой объект, который может определять порядок ваших объектов. Такой объект называется компаратором – это интерфейс.

Вот первый класс для объектов, которые мы хотим отсортировать:

private static class Employee{
    public String name;
    public int    employeeId;

    public Employee(String name, int employeeId){
        this.name       = name;
        this.employeeId = employeeId;
    }
}

Класс Employee – это простая модель сотрудника, у которого есть имя и идентификатор. Вы можете отсортировать массив объектов Employee по имени или по идентификатору сотрудника.

Вот первый пример сортировки массива объектов Employee по их имени с помощью метода Arrays.sort():

Employee[] employeeArray = new Employee;

employeeArray = new Employee("Xander", 1);
employeeArray = new Employee("John"  , 3);
employeeArray = new Employee("Anna"  , 2);

java.util.Arrays.sort(employeeArray, new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.name.compareTo(e2.name);
    }
});


for(int i=0; i < employeeArray.length; i++) {
    System.out.println(employeeArray.name);
}

1. Сначала объявляется массив.
2. Три объекта Employee создаются и вставляются в массив.
3. Метод Arrays.sort() вызывается для сортировки массива. В качестве параметра передаем массив employee и реализацию Comparator, которая может определять порядок объектов Employee. Это создает анонимную реализацию интерфейса Comparator.

В примере важно уловить реализацию метода compare() анонимной внутренней реализации интерфейса Comparator. Этот метод возвращает:

• положительное число, если первый объект «больше»(позже в порядке сортировки), чем второй объект;
• 0 – они «равны»(в порядке сортировки);
• отрицательное число, если первый объект «меньше» (ранее в порядке сортировки), чем второй объект.

В приведенном выше примере мы просто вызываем метод String.compare(), который выполняет для нас сравнение (сравнивает имена сотрудников).

После сортировки массива мы перебираем его и выводим имена сотрудников. Вывод:

Anna
John
Xander

Обратите внимание, как порядок был изменен по сравнению с порядком, в котором они были первоначально вставлены в массив. Сортировка объектов Employee по их идентификатору сотрудника на основании предыдущего примера с измененной реализацией метода compare() анонимной реализации интерфейса Comparator:

Сортировка объектов Employee по их идентификатору сотрудника на основании предыдущего примера с измененной реализацией метода compare() анонимной реализации интерфейса Comparator:

Employee[] employeeArray = new Employee;

employeeArray = new Employee("Xander", 1);
employeeArray = new Employee("John"  , 3);
employeeArray = new Employee("Anna"  , 2);

java.util.Arrays.sort(employeeArray, new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        return e1.employeeId - e2.employeeId;
    }
});

for(int i=0; i < employeeArray.length; i++) {
    System.out.println(employeeArray.name);
}

Вывод:

Xander
Anna
John

Чтобы сравнить объекты Employee в массиве сначала по их имени, а если оно совпадает, то по их идентификатору сотрудника, реализация compare():

java.util.Arrays.sort(employeeArray, new Comparator() {
    @Override
    public int compare(Employee e1, Employee e2) {
        int nameDiff = e1.name.compareTo(e2.name);
        if(nameDiff != 0) { return nameDiff; }
    
        return e1.employeeId - e2.employeeId;
    }
});

Java.util.Arrays: готовые решения для обработки массивов

Наиболее часто используемые операции по работе с java-массивами:

• сортировка;
• поиск нужного элемента;
• преобразование массива в строку.

Одним из самых удобных способов решения такого рода задач является использование класса Arrays пакета java.util. Рассмотрим на примере их реализацию:

class Main {
    public static void main(String[] args) {
        int[] test = {1, 5, 4, 3, 7}; //объявление и инициализация массива
        System.out.println(test); //попытка вывода нашего массива в консоль (результат 16-ричное число)
        System.out.println(Arrays.toString(test)); //выводим в консоль массив при помощи метода toString и радуемся правильному результату
        Arrays.sort(test, 0, 4); //сортировка массива от 0-й до 4-й ячейки
        System.out.println(Arrays.toString(test)); //выводим результат сортировки
        int keyArray = Arrays.binarySearch(test, 8); // поиск keyArray - т.е. числа 8 в отсортированном массиве, метод binarySearch выдает индекс искомого элемента
        System.out.println(keyArray); //выводим в консоль этот индекс
System.out.println(Arrays.binarySearch(test, 0)); //пробуем найти элемент, отсутствующий в массиве и выводим результат в консоль
    }
}

Выведет:

 
3 
-1

Сортировка массивов

 Метод  Arrays.sort([]a)

Метод sort() из класса Arrays использует усовершенствованный алгоритм Быстрой сортировки (Quicksort), который эффективен  для большинства  набора данных.  Метод упорядочивает весь массив в порядке возрастания значений элементов.

Формат метода

Arrays.sort([]a),

[]a – исходный массив, после работы метода массив будет содержать упорядоченные значения элементов в порядке возрастания.

Пример.

//исходный массив
double a[] = { 41.5, 11.4, 11.2, 3.1, 4.3, 5.5 };
//сортировка
Arrays.sort(a);
//результат сортировки
for(int i=0; i<a.length; i++)
System.out.print(a+"  ");  //3.1  4.3  5.5  11.2  11.4  41.5 
System.out.println();

 Метод  Arrays.sort([]a,index1,index2)

выполняет сортировку части массива по возрастанию массива от index1 до index2 минус единица

 Формат метода

Arrays.sort([]a,index1,index2),

 []a – исходный массив

index1, index2 — начальный и конечный индексы, определяющие диапазон упорядочивания элементов по возрастанию. 

Пример.

//исходный массив
int b[] ={2,1,0,50,30,20,10};
//сортировка  от 0 элемента до 3, сам третий элемент не входит
Arrays.sort(b,0,3);
//результат сортировки
for(int i=0; i<b.length; i++)
System.out.print(b+"  ");  // 0  1  2  50  30  20  10
System.out.println();
 
//сортировка  элементов от 3 до конца массива bb.length
Arrays.sort(b,3,b.length);
for(int i=0; i<b.length; i++)
System.out.print(b+"  "); //0  1  2  10  20  30  50
System.out.println();

 Сортировка  массива по убыванию

Формат метода

 Arrays.sort([]a, Collections.reverseOrder());

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

Пример.

//// сортировrка по убыванию
//вместо примитивного типа double
//используем объектный тип   Double
   Double a[] = new Double;
   //заполняем массив случаными числами
   for(int i = 0; i <  a.length; i++) {
     a =  (double)(Math.random() * 20);
      System.out.format("%.2f   ", a);
         }
System.out.println();  
System.out.println("Массив,отсотированный по убыванию");
//Сортируем массив
    Arrays.sort(a, Collections.reverseOrder());
//Выводим отсортированный массив на консоль.
for(int i = 0; i <  a.length; i++) {
     System.out.format("%.2f   ", a);
     }
System.out.println();  

Результат

15,39   1,54   17,47   15,50   3,83   16,43   18,87   15,54   8,23   12,97  

Массив,отсотированный по убыванию

18,87   17,47   16,43   15,54   15,50   15,39   12,97   8,23   3,83   1,54   

Java array accessing elements

After the array is created, its elements can be accessed by their index.
The index is a number placed inside square brackets which follow the
array name.

com/zetcode/AccessingElements.java

package com.zetcode;

public class AccessingElements {

    public static void main(String[] args) {

        String[] names = {"Jane", "Thomas", "Lucy", "David"};

        System.out.println(names);
        System.out.println(names);
        System.out.println(names);
        System.out.println(names);
    }
}

In the example, we create an array of string names. We access each of the
elements by its index and print them to the terminal.

String[] names = {"Jane", "Thomas", "Lucy", "David"};

An array of strings is created.

System.out.println(names);
System.out.println(names);
System.out.println(names);
System.out.println(names);

Each of the elements of the array is printed to the console. With the
construct, we refer to the first element of the names array.

$ java AccessingElements.java
Jane
Thomas
Lucy
David

Running the example we get the above output.

It is possible to change the elements of an array. The elements are
not immutable.

com/zetcode/AccessingElements2.java

package com.zetcode;

import java.util.Arrays;

public class AccessingElements2 {

    public static void main(String[] args) {

        int[] vals = { 1, 2, 3 };

        vals *= 2;
        vals *= 2;
        vals *= 2;

        System.out.println(Arrays.toString(vals));
    }
}

We have an array of three integers. Each of the values will be multiplied by
two.

int[] vals = { 1, 2, 3 };

An array of three integers is created.

vals *= 2;
vals *= 2;
vals *= 2;

Using the element access, we multiply each value in the array by two.

$ java AccessingElements2.java

All three integers have been multiplied by number 2.

Применение массивов

Как только массив инициализирован, можно задавать элементам значения при помощи индекса. Он определяет позицию каждого элемента внутри массива. Первый элемент занимает позицию , второй – 1 и так далее.

Важно отметить, что индекс первого элемента –. Обычно путаница возникает тогда, когда начинаешь думать, что раз в массиве 10 элементов, то их индексы будут перечисляться с 1 до 10

Но на самом деле счет идет от до 9. Например, возвращаясь к примеру с лотерей, можно создать массив из 6 элементов, и задать им числа из лотереи:

int[] lotteryNumbers = new int;
lotteryNumbers = 16;
lotteryNumbers = 32;
lotteryNumbers = 12;
lotteryNumbers = 23;
lotteryNumbers = 33;
lotteryNumbers = 20;

Сокращённый способ заполнения массива:

int[] lotteryNumbers = {16,32,12,23,33,20};

String[] names = {"John", "James", "Julian", "Jack", "Jonathon"};

Значения каждого элемента перечисляются внутри фигурных скобок. Порядок значений определяет, какое значение будет у каждого элемента, начиная с нулевой позиции.

Чтобы получить значение элемента, используется его индекс:

System.out.println("The value of the first element is " + lotteryNumbers);

Как определяется длина массива Java? Чтобы узнать  длину массива, в Java используется поле length:

System.out.println("The lotteryNumbers array has " + lotteryNumbers.length + " elements");

Примечание: распространена ошибка при использовании метода length, когда значение length используется как индексная позиция. Это всегда выдаст ошибку, так как индексные позиции массива , в то время как позиция length – 1.

Перебор Элементов

Мы можем перебирать многомерный массив, как и любой другой массив в Java.

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

void initializeElements(int[][] multiDimensionalArr) {
    Scanner sc = new Scanner(System.in);
    for (int outer = 0; outer < multiDimensionalArr.length; outer++) {
        for (int inner = 0; inner < multiDimensionalArr.length; inner++) {
            multiDimensionalArr = sc.nextInt();
        }
    }
}

Здесь Многомерный Arr.длина – это длина массива с индексом внешний в многомерном Arr .

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

Инициализация массива

Инициализация — это заполнение массива конкретными данными, а не данными по умолчанию.

Нижеследующий код позволит создать массив, включающий в себя 4 сезона года. Также мы выполним заполнение массива строками-названиями сезонов:

String[] seasons  = new String4]; /* выполнили объявление и создание массива из 4 строк, где по умолчанию записано null, ведь строка — ссылочный тип данных*/

seasons = "Winter"; /* в первую ячейку записали строку Winter*/
seasons1 = "Spring"; /* во вторую ячейку (номер 1) записали строку Spring и т. д.*/
seasons2 = "Summer"; 
seasons3 = "Autumn"; 

Так мы записали названия всех сезонов. Но в принципе можно всё сделать проще, совместив инициализацию и объявление:

String[] seasons  = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Или даже так, опустив оператор new:

String[] seasons  = {"Winter", "Spring", "Summer", "Autumn"};

Инициализируем массив, работаем с его элементами

Теперь мы знаем, что такое массив, но как его использовать — пока непонятно. Как загружать в него информацию, а потом ее оттуда извлекать? Давайте разбираться.

В широком смысле массив — это самая важная структура данных в программировании. Сам компьютер — это не что иное, как набор массивов. Байт — это массив из восьми двоичных разрядов, а строка — это массив символов.

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

Из-за операционной системы, виртуальной памяти и других факторов для извлечения элемента из массива может потребоваться несколько больше, чем один фактический компьютерный цикл. Но время извлечения первого элемента такое же, как и 100-го элемента и 500-тысячного. Никакая другая созданная нами структура данных не может быть быстрее, чем массив. Все «продвинутые» системы реализованы с их использованием.

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

Например, создадим массив, содержащий в себе четыре стороны света, и заполним его значениями:

String[] sides  = new String; /* объявленному массиву Java выделил память для четырех строк (по умолчанию их значение будет null, потому что String относится к ссылочному типу)*/
sides = "North"; /* Получив доступ к первой ячейке (с нулевым индексом), мы вписали туда  строковое значение  */
sides = "South"; // тоже самое мы проделываем с ячейкой под индексом 1
sides = "West"; // 2
sides = "East"; // 3

Мы используем индексы для доступа к ячейкам массива, число в скобках обозначает каждую конкретную позицию. Если переданный при доступе к ячейке индекс — отрицательный или превышает длину массива, Java выдаст исключение .

Теперь совместим инициализацию с объявлением:

String[] sides = new String[] {"North", "South", "West", "East"};

И уберем оператор , тем самым упростив запись:

String[] sides = {"North", "South", "West", "East"};