8. Массивы

[admin]

Два способа объявления массива:

тип_данных название_массива[];
// или
тип_данных[] название_массива;

Создание массива производится с помощью следующей конструкции:

new тип_данных[количество_элементов]

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

В данном примере мы объявляем массив и потом инициализируем его:

int nums[];
nums = new int[4];  // массив из 4 чисел

Но можно сразу при объявлении массива инициализировать его (так же как и с переменными):

int[] nums = new int[4];   // массив из 4 чисел

При такой инициализации массива все элементы имеют значение по умолчанию:

• для числовых типов (в том числе для типа char) это число 0
• для типа boolean это значение false
• для остальных объектов это значение null (нулевой)

Для каждого элемента массива при его создании, можно назначить свое значение:

int[] nums = new int[] {1, 2, 3, 4};
System.out.println(nums[3]);

В таком случае в квадратных скобках не указывается размер массива, так как каждому элементу массива, мы назначили свое значение в фигурных скобках.
Индексация элементов массива начинается с 0, то есть 0, 1, 2, 3. Поэтому в данном случае, чтобы обратиться к четвертому элементу в массиве, нам надо использовать выражение nums[3].

 

[admin]

Есть пример:

public class Program {
    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);
    }
}

Почему ответ: 58?
Свойство length, возвращающее длину массива (количество его элементов). В данном случае, длина массива: 4

 

[pisikot]

Все верно, length возвращает размер массива, в данном примере 4
Ты эту 4ку ставишь в условия цикла вот так получается (int x=0; x < 4; x++) т.е. цикл выполнится 4 раза до тех пор пока х не будет равен 4...
x = 4 условие вернет false и цикл завершится.

на каждой итерации цикла происходит sum += myArr[x], возможно будет понятнее такая запись sum = sum + myArr[x];

1й шаг цикла
x = 0, sum = 0
в переменную sum идет выражение = sum (0) + myArr[0] (в myArr под индексом 0 лежит цифра = 6) т.е. получается 0 + 6 = 6

2й шаг цикла
x = 1, sum 6
sum = sum + myArr[1] (в sum хранится 6, а в myArr под индексом 1 лежит цифра 42) т.е. 6 + 42 = 48

3й шаг цикла
x = 2, sum 48
sum = sum + myArr[2] (в sum хранится 48, а в myArr под индексом 2 лежит цифра 3) т.е. 48 + 3 = 51

4й шаг цикла
x = 3, sum 51
sum = sum + myArr[3] (в sum хранится 51, а в myArr под индексом 3 лежит цифра 7) т.е. 51 + 7 = 58

Затем х становиться 4 и условие x < 4 не выполняется, а значит мы выходим из цикла с sum = 58

 

[admin]

pisikot дошло до меня... Не сразу, но дошло.

 

[admin]

Интересный примеры:

Spoiler: Вывод четных и нечетных элементов массива

public class Main {

    public static void main(String[] args) {
        // Массива myArray из 5 элементов типа double.
        double[] myList = {2, 2.7, 3, 12, 23.8};

        // Вывод четных элементов массива на экран.
        System.out.print("Четные элементы массива myList: ");
        for (int i = 0; i < myList.length; i++) {
            if(myList[i]%2 == 0){
                System.out.print(myList[i] + ", ");
            }
        }

        // Вывод нечетных элементов массива на экран.
        System.out.print("\nНечетные элементы массива myList: ");
        for (int i = 0; i < myList.length; i++) {
            if(myList[i]%2 != 0){
                System.out.print(myList[i] + ", ");
            }
        }
    }
}

Получаем:

Четные элементы массива myList: 2.0, 12.0,
Нечетные элементы массива myList: 2.7, 3.0, 23.8,

Spoiler: Вывод элементов массива с четным и нечетным индексом

public static void main(String[] args) {
        // Массив myArray из 5 элементов типа double.
        double[] myList = {11.5, 1.9, 5.32, 8.8, 15.8};

        // Вывод элементов массива с четным индексом на экран.
        System.out.print("Элементы массива myList с четным индексом: ");
        for (int i = 0; i < myList.length; i++) {
            if(i%2 == 0){
                System.out.print("индекс " + i + " = " + myList[i] + ", ");
            }
        }

        // Вывод элементов массива с нечетным индексом на экран.
        System.out.print("\nЭлементы массива myList с нечетным индексом: ");
        for (int i = 0; i < myList.length; i++) {
            if(i%2 != 0){
                System.out.print("индекс " + i + " = " + myList[i] + ", ");
            }
        }
    }
}

Получаем:

Элементы массива myList с четным индексом: индекс 0 = 11.5, индекс 2 = 5.32, индекс 4 = 15.8,
Элементы массива myList с нечетным индексом: индекс 1 = 1.9, индекс 3 = 8.8,

 

[admin]

Допустим, есть массив, с количеством элементов 10000.:

public static void main(String[] args) {
        int[] num = new int[10000];

Требуется присвоить каждому элементу массива число 5.

При небольшом количестве элементов в массиве, можно сделать просто:

name[0] = 5;
name[1] = 5;
name[2] = 5;
name[3] = 5;

Но в нашем случае, элементов 10000..., так что делаем с помощью цикла for:

public class Main {

    public static void main(String[] args) {
        int[] name = new int[10000];

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

Немного подправлю код. Объявлю целочисленную переменную i, в цикле (так красивее):

public class Main {

    public static void main(String[] args) {
        int[] name = new int[10000];
       
        for (int i = 0; i < name.length; i++) {
            name[i] = 5;
            System.out.println(name[i]);
        }
    }
}