Лекция: массивы

Example: Compute Sum and Average of Array Elements

Output:

Sum = 36
Average = 3.6

In the above example, we have created an array of named numbers. We have used the loop to access each element of the array.

Inside the loop, we are calculating the sum of each element. Notice the line,

Here, we are using the length attribute of the array to calculate the size of the array. We then calculate the average using:

As you can see, we are converting the value into . This is called type casting in Java. To learn more about typecasting, visit Java Type Casting.

Multidimensional Arrays

Arrays we have mentioned till now are called one-dimensional arrays. However, we can declare multidimensional arrays in Java.

A multidimensional array is an array of arrays. That is, each element of a multidimensional array is an array itself. For example,

Here, we have created a multidimensional array named matrix. It is a 2-dimensional array. To learn more, visit the Java multidimensional array.

Recommended Readings

• Java Copy Array
• Java Program to Print an Array
• Java Program to Concatenate two Arrays
• Java ArrayList to Array and Array to ArrayList
• Java Dynamic Array

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.

Перейдём к практике

Приступим к созданию массива объектов. Представьте, что у нас есть класс ObjMass и всё, что в нём есть, — это массив объектов Dog из трёх элементов:

    public class ObjMass {
    Dog[] name = new Dog 3];
}

Прекрасно. Но так как класс Dog мы раньше не описывали (интерпретатор Java знать не знает, что такое Dog и откуда его взять), то название объекта выделится красным. Исправим это, создав параллельно класс Dog:

    class ObjMass {
    Dog[] abc = new Dog 3];
}

class Dog{

}

Так, хорошо. Но зачем нам массив, состоящий из пустых объектов? Пусть у собак будут хотя бы клички:

    class ObjMass {
    Dog[] abc = new Dog 3];
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Вот, теперь Dog имеет содержание.

Давайте сейчас обратимся к объектам, которые ещё не созданы, как говорится, расширим пример

Обратите ваше внимание, что у нас перед массивом объектов Dog находится модификатор static. Также добавим метод main:

    class ObjMass {
    static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        }
    }
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Для вывода массива на экран создаём цикл. И выводим не имена собак (abc.name), а объекты — abc:

    class ObjMass {
   static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        for (int i = ; i<3; i++){
            System.out.println(abci]);
        }
    }
}
class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

И увидим следующий результат:

null
null
null

Это и есть значения по умолчанию, при ссылке на которые возникнет ошибка NullPointerException. Она появляется, когда мы ссылаемся на свойство null-ного объекта. К примеру, давайте попробуем вывести на экран имена собак (abc.name):

    class ObjMass {
   static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        for (int i = ; i<3; i++){
            System.out.println(abciname);
        }
    }
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Результатом станет тот самый NullPointerException. Чтобы этого не допустить, массив объектов надо заполнить:

    class ObjMass {
   static Dog[] abc = new Dog 3];

    public static void main (String[] args){
        abc = new Dog("Billy");
        abc1 = new Dog("Tom");
        abc2 = new Dog("Jonny");

        for (int i = ; i<3; i++){
            System.out.println(abciname);
        }
    }
}

class Dog{
   String name;

    public Dog (String name){
        this.name = name;
    }
}

Результат выполнения кода:

Billy 
Tom 
Jonny 

Вот и всё, теперь вы знакомы с особенностями применения массива объектов в Java и знаете, как добавить объект в массив. В прочих аспектах всё функционирует практически так же, как и в массивах примитивных типов.

Итерация

Как перебрать все элементы массива, используя цикл 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 );
}

В этом примере:

1. Сначала создается массив ссылок String. Когда  впервые создаете массив ссылок на объекты, каждая из ячеек в массиве указывает на ноль, а не на объект.
2. Первый из двух циклов for выполняет итерацию по массиву String, создает строку и делает ссылку на ячейку этой строкой.
3. Второй из двух циклов 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);
}

Карта массива к другому типу

Часто полезно применять операции на всех элементов массива, возможно, превращая их в другой тип объекта.

С этой целью, Мы постараемся создать гибкий метод помощников с использованием Generics:

public static  U[] mapObjectArray(
  T[] array, Function function,
  Class targetClazz) {
    U[] newArray = (U[]) Array.newInstance(targetClazz, array.length);
    for (int i = 0; i < array.length; i++) {
        newArray = function.apply(array);
    }
    return newArray;
},>,>

Если мы не используем Java 8 в нашем проекте, мы можем отказаться от Функциональные аргумент, и создать метод для каждого отображения, что мы должны выполнить.

Теперь мы можем повторно использовать наш общий метод для различных операций. Давайте создадим два тестовых случая, чтобы проиллюстрировать это:

@Test
public void whenMapArrayMultiplyingValues_thenReturnMultipliedArray() {
    Integer[] multipliedExpectedArray = new Integer[] { 6, 10, 4, 10, 28, 8 };
    Integer[] output = 
      MyHelperClass.mapObjectArray(array, value -> value * 2, Integer.class);

    assertThat(output).containsExactly(multipliedExpectedArray);
}

@Test
public void whenMapDividingObjectArray_thenReturnMultipliedArray() {
    Double[] multipliedExpectedArray = new Double[] { 1.5, 2.5, 1.0, 2.5, 7.0, 2.0 };
    Double[] output =
      MyHelperClass.mapObjectArray(array, value -> value / 2.0, Double.class);

    assertThat(output).containsExactly(multipliedExpectedArray);
}

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

В качестве альтернативы мы можем обратиться к Потоки Java 8 для выполнения отображения для нас.

Нам нужно превратить массив в Поток Объект s в первую очередь. Мы можем сделать это с Arrays.stream метод.

Например, если мы хотим составить карту наших int значения пользовательского Струнные представительство, мы будем осуществлять это:

String[] stringArray = Arrays.stream(array)
  .mapToObj(value -> String.format("Value: %s", value))
  .toArray(String[]::new);

Java searching arrays

The class has a simple method for searching elements in an
array. It is called the . The method searches for
elements using a binary search algorithm. The method
only works on sorted arrays.

com/zetcode/Searching.java

package com.zetcode;

import java.util.Arrays;

public class Searching {

    public static void main(String[] args) {

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

        Arrays.sort(planets);

        String p = "Earth";

        int r = Arrays.binarySearch(planets, p);

        String msg;

        if (r >= 0) {
            msg = String.format("%s was found at position %d of the "
                    + "sorted array", p, r);
        } else {
            msg = p + " was not found";
        }

        System.out.println(msg);
    }
}

In the example, we search for the «Earth» string in an array of planets.

Arrays.sort(planets);

Since the algorithm only works on sorted arrays, we must sort the array
first.

String p = "Earth";

We will be searching for the «Earth» element.

int r = Arrays.binarySearch(planets, p);

The method is called. The first parameter
is the array name, the second the element we are looking for.
If the element is found, the return value is greater or equal to zero.
In such a case, it is the index of the element in the sorted array.

if (r >= 0) {
    msg = String.format("%s was found at position %d of the "
            + "sorted array", p, r);
} else {
    msg = p + " was not found";
}

Depending on the returned value, we create a message.

$ java Searching.java
Earth was found at position 0 of the sorted array

This is the example output.

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

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

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 irregular arrays

Arrays that have elements of the same size are called rectangular arrays. It is
possible to create irregular arrays where the arrays have a different size. In
C# such arrays are called jagged arrays.

com/zetcode/IrregularArrays.java

package com.zetcode;

public class IrregularArrays {

    public static void main(String[] args) {

        int[][] ir = new int[][] {
            {1, 2},
            {1, 2, 3},
            {1, 2, 3, 4}
        };

        for (int[] a : ir) {
            for (int e : a) {
                System.out.print(e + " ");
            }
        }

        System.out.print('\n');
    }
}

This is an example of an irregular array.

int[][] ir = new int[][] {
    {1, 2},
    {1, 2, 3},
    {1, 2, 3, 4}
};

This is a declaration and initialization of an irregular array.
The three inner arrays have 2, 3, and 4 elements.

for (int[] a : ir) {
    for (int e : a) {
        System.out.print(e + " ");
    }
}

The enhanced for loop is used to go through all the
elements of the array.

$ java IrregularArrays.java
1 2 1 2 3 1 2 3 4

This is the output of the example.

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

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

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

Пример:

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

или

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

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

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

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);

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

class GFG { public static void main (String[] args) { // declares an Array of integers. int[] arr;

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

// initialize the first elements of the array arr = 10;

// initialize the second elements of the array arr = 20;

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

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

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

Перебор массива объектов в Java

Представьте, что у нас есть класс Book, реализующий книгу:

class Book {
    String title; // название 
    String author; // автор
    float price; // цена
    int year; // год выпуска
}

Давайте выполним перебор этого массива объектов, используя расширенный цикл for:

// объявляем одномерный массив типа Book
Book B[];

// выделяем память для массива из четырёх ссылок на тип Book
B = new Book4];

// выделяем память для каждого элемента нашего массива 
for (int i=; i<B.length; i++)
    Bi = new Book();

// заполняем массив значениями
Btitle = "Book-1";
Bauthor = "Author-1";
Bprice = 205.78f;
Byear = 2008;

B1title = "Book-2";
B1author = "Author-2";
B1price = 99.00f;
B1year = 2010;

B2title = "Book-3";
B2author = "Author-3";
B2price = 0.99f;
B2year = 2011;

B3title = "Book-4";
B3author = "Author-4";
B3price = 100.01f;
B3year = 2012;

// выполняем поиск книг 2011-2012 гг
for (Book book  B)
    if ((book.year==2011)||(book.year==2012))
        System.out.println("Book: " + book.title + ", " + book.author);

Результат перебора этого массива объектов в Java будет следующим:

Book: Book-3, Author-3
Book: Book-4, Author-4

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

Минус массива — статичность, то есть необходимость задавать размер заранее. Для этого и придумали динамический массив, который может менять размер в процессе выполнения программы.
Например, статические массивы работают по следующей схеме:

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

Так как для копирования массива используется специальная нативная функция, проблем с «переездом» не возникает.

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

Плюсы и минусы расширенного цикла for для Java-массивов

Применение расширенного цикла for имеет ряд преимуществ:
• повышенная рациональность и упрощённость, если сравнивать со стандартным использованием цикла for;
• отпадает необходимость в применении дополнительной переменной цикла, не надо задавать её начальное значение, как и условие завершения цикла;
• массив индексировать тоже не нужно;
• такой цикл очень удобен при обработке коллекций.

Но есть и недостаток, который связан с тем, что у нас отсутствует доступ к индексу массива. В результате у нас снижается гибкость в оперировании итерационной переменной. А это иногда нужно, допустим, если надо выполнить перебор не всех элементов массива или коллекции. К примеру, в некоторых случаях у программистов возникают задачи по перебору лишь первых n-элементов либо элементов, лежащих на определённых позициях (четных или нечётных). Правда, данный недостаток мы можем обойти, если введём дополнительные переменные-итераторы и проверку соответствующих условий. Тем не менее лучше всего этот способ подходит именно для обычного перебора всех элементов массива в Java.

Хотите знать больше? Приходите на профессиональный курс по Java-программированию в OTUS!

При подготовке статьи использовались следующие публикации:
«Массив».
«Расширенный цикл for в стиле foreach. Обработка массивов, коллекций объектов ArrayList».

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

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

// Java program to demonstrate
// Class Objects for Arrays

class Test
{
public static void main(String args[])
{
int intArray[] = new int;
byte byteArray[] = new byte;
short shortsArray[] = new short;

// array of Strings
String[] strArray = new String;

System.out.println(intArray.getClass());
System.out.println(intArray.getClass().getSuperclass());
System.out.println(byteArray.getClass());
System.out.println(shortsArray.getClass());
System.out.println(strArray.getClass());
}
}

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

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

Клонирование массивов

При клонировании одномерного массива, например Object[], выполняется копия с новым массивом, содержащим копии элементов исходного, а не ссылки.

// Java program to demonstrate
// cloning of one-dimensional arrays

class Test
{
public static void main(String args[])
{
int intArray[] = {1,2,3};

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+" ");
}
}
}

Клон многомерного массива (например, Object [] []) является копией и это означает, что он создает только один новый массив с каждым элементом и ссылкой на исходный массив элементов, но вложенные массивы являются общими.

// Java program to demonstrate
// cloning of multi-dimensional arrays

class Test
{
public static void main(String args[])
{
int intArray[][] = {{1,2,3},{4,5}};

int cloneArray[][] = intArray.clone();

// will print false
System.out.println(intArray == cloneArray);

// will print true as shallow copy is created
// i.e. sub-arrays are shared
System.out.println(intArray == cloneArray);
System.out.println(intArray == cloneArray);

}
}

Оцени статью

Оценить

Средняя оценка / 5. Количество голосов:

Видим, что вы не нашли ответ на свой вопрос.

Помогите улучшить статью.

Спасибо за ваши отзыв!

Многомерные 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 initializing arrays

There are several ways how we can initialize an array in Java. In the first
example, an array is created and initialized in two steps.

com/zetcode/InitArray.java

package com.zetcode;

import java.util.Arrays;

public class InitArray {

    public static void main(String[] args) {

        int[] a = new int;

        a = 1;
        a = 2;
        a = 3;
        a = 4;
        a = 5;

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

We create and initialize a numerical array. The contents of the
array are printed to the console.

int[] a = new int;

Here we create an array which can contain five elements. The statement allocates
memory for five integers. The square brackets are used for declaring an array,
the type ( in our case) tells us what type of values the array will
hold. An array is an object and therefore it is created with the
keyword.

a = 1;
a = 2;
a = 3;
a = 4;
a = 5;

We initialize the array with some data. This is assignment initialization.
The indexes are in the square brackets. Number 1 is going to be the first
element of the array, number 2 is the second etc.

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

The class is a helper class which contains various methods for
manipulating arrays. The method returns a string representation
of the contents of the specified array. This method is helpful in debugging.

$ java InitArray.java

This is the output of the example.

We can declare and initialize an array in one statement.

com/zetcode/InitArray2.java

package com.zetcode;

import java.util.Arrays;

public class InitArray2 {

    public static void main(String[] args) {

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

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

This is a modified version of the previous program.

int[] array = new int[] { 2, 4, 5, 6, 7, 3, 2 };

An array is created and initialized in one step. The elements
are specified in curly brackets. We did not specify the length
of the array. The compiler will do it for us.

The one step creation and initialization can be further simplified
by only specifying the numbers between the curly brackets.

com/zetcode/InitArray3.java

package com.zetcode;

import java.util.Arrays;

public class InitArray3 {

    public static void main(String[] args) {

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

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

An array of integers is created using the most simple way
of array creation.

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

The construct can be omitted. The right side of the
statement is an array literal notation. It resembles the C/C++ style of
array initialization. Even if we drop the keyword, the array is
created the same way as in previous two examples. This is just a convenient
shorthand notation.

How to Initialize Arrays in Java?

In Java, we can initialize arrays during declaration. For example,

Here, we have created an array named age and initialized it with the values inside the curly brackets.

Note that we have not provided the size of the array. In this case, the Java compiler automatically specifies the size by counting the number of elements in the array (i.e. 5).

In the Java array, each memory location is associated with a number. The number is known as an array index. We can also initialize arrays in Java, using the index number. For example,

Java Arrays initialization

Note:

• Array indices always start from 0. That is, the first element of an array is at index 0.
• If the size of an array is n, then the last element of the array will be at index n-1.

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

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

Класс Object  имеет метод equals, который наследуется массивами и не является перегруженным и сравнение идет по адресам объектов, а не по содержимому. Метод  equals перегружен только в классе Arrays. Отсюда вытекает правило сравнения массивов:

• a == b сравниваются адреса массивов
• a.equals(b) сравниваются адреса массивов
• Arrays.equals(a, b) сравнивается содержимое массивов
• Arrays.deepEquals(a, b) сравнивается содержимое многомерных массивов

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

Boolean f=Arrays.equals([]a,[]b);

Метод вернет true, если содержимое массивов равно, в противном случае false.

Пример.

int ar1[] = {0,2,3,4,5,1};
int ar2[] = {0,2,3,4,5,1};
//это сравнение ссылок      
System.out.println(ar1.equals(ar2));  //вернет fasle
//это сравнение содержимового
System.out.println(Arrays.equals(ar1,ar2)); // вернет true
System.out.println("");
    ar1=6;
System.out.println(Arrays.equals(ar1,ar2)); // вернет false
System.out.println("");

Вывод одномерных массивов

Имеется достаточно удобный метод вывода данных одномерного массива — Arrays.toString([]a, который возвращает строковое представление массива со строковым представлением элементов, заключенных в квадратные скобки.

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

String str=Arrays.toString([]a);

Пример.

//Вывод одномерных массивов с помощью метода toString()
String[] str = {"Красный",  "Синий",  "Зеленый"};
                               
System.out.println("Это адрес: " +str);
System.out.println("Это значения: " + Arrays.toString(str));
System.out.println();
//выполним печать массива до и после сортировки
int[] a = {7, 2, 9, 1, 0, 3, 4, 8, 5, 6};
System.out.println("До сортировки: "+Arrays.toString(a));
Arrays.sort(a);
System.out.println("После сортировки: "+ Arrays.toString(a));

Будет выведено:

Это адрес: [Ljava.lang.String;@1db9742

Это значения:

До сортировки:

После сортировки: