Что получишь, если обратиться к элементу массива целых чисел с индексом 3

Обращение к элементу массива целых чисел по индексу

Этот вопрос касается базовых операций с массивами. Ответ зависит от того, что находится в массиве на позиции с индексом 3.

Основная концепция

Массив в Java - это упорядоченная последовательность элементов одного типа, которые хранятся в памяти подряд. Каждый элемент доступен по его индексу.

// Создание массива целых чисел
int[] numbers = new int[5];  // Массив из 5 элементов
// Массив автоматически инициализируется нулевыми значениями
// numbers[0] = 0
// numbers[1] = 0
// numbers[2] = 0
// numbers[3] = 0
// numbers[4] = 0

// Обращение к элементу с индексом 3
int value = numbers[3];  // Получим 0
System.out.println(value);  // Output: 0

Инициализация с явными значениями

Если массив инициализирован с конкретными значениями, вы получите конкретное значение.

// Создание и инициализация массива одновременно
int[] numbers = {10, 20, 30, 40, 50};
// Индексы:     0   1   2   3   4

int element = numbers[3];  // Получим 40
System.out.println(element);  // Output: 40

Индексирование начинается с нуля

Это ключевой момент - в Java (и большинстве языков программирования) индексирование начинается с 0.

int[] array = {100, 200, 300, 400, 500};
//            0    1    2    3    4   <- индексы

array[0] == 100;  // Первый элемент
array[1] == 200;  // Второй элемент
array[2] == 300;  // Третий элемент
array[3] == 400;  // Четвертый элемент
array[4] == 500;  // Пятый элемент

// Попытка доступа к array[5] выбросит ArrayIndexOutOfBoundsException

Ошибка: выход за границы массива

Если индекс больше или равен длине массива, произойдет исключение.

int[] numbers = {1, 2, 3};  // Массив из 3 элементов (индексы 0, 1, 2)

try {
    int value = numbers[3];  // INDEX OUT OF BOUNDS!
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Ошибка: индекс вне границ массива");
    System.out.println("Длина массива: " + numbers.length);
    System.out.println("Пытались получить индекс: 3");
}

Проверка длины массива перед доступом

Всегда хорошо проверить, что индекс существует.

public class ArrayAccess {
    public static int safeGetElement(int[] array, int index) {
        if (index < 0 || index >= array.length) {
            throw new IllegalArgumentException(
                "Индекс " + index + " вне границ массива длиной " + array.length
            );
        }
        return array[index];
    }

    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        
        System.out.println(safeGetElement(numbers, 0));   // 10
        System.out.println(safeGetElement(numbers, 3));   // 40
        System.out.println(safeGetElement(numbers, 4));   // 50
        System.out.println(safeGetElement(numbers, 5));   // IllegalArgumentException
    }
}

Доступ к элементам разных типов массивов

// Массив int
int[] intArray = {1, 2, 3, 4, 5};
int intValue = intArray[3];  // 4 (примитивный тип int)

// Массив Integer (обертка)
Integer[] integerArray = {10, 20, 30, 40, 50};
Integer integerValue = integerArray[3];  // 40 (объект Integer)

// Массив String
String[] strings = {"a", "b", "c", "d", "e"};
String stringValue = strings[3];  // "d" (String объект)

// Многомерный массив
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
int value = matrix[3][3];  // ArrayIndexOutOfBoundsException (нет строки 3)
int correctValue = matrix[1][2];  // 6

Цикл по массиву

public class ArrayIteration {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};

        // Классический цикл for
        for (int i = 0; i < numbers.length; i++) {
            int element = numbers[i];
            if (i == 3) {
                System.out.println("Элемент с индексом 3: " + element);  // 40
            }
        }

        // Enhanced for loop (for-each)
        for (int element : numbers) {
            // Но так не узнаем индекс
        }

        // Stream API (Java 8+)
        IntStream.range(0, numbers.length)
            .filter(i -> i == 3)
            .forEach(i -> System.out.println("Элемент[" + i + "]: " + numbers[i]));
    }
}

Практический пример: поиск элемента

public class ArraySearch {
    /**
     * Найти индекс элемента в массиве
     */
    public static int findIndex(int[] array, int value) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == value) {
                return i;  // Найден
            }
        }
        return -1;  // Не найден
    }

    public static void main(String[] args) {
        int[] numbers = {100, 200, 300, 400, 500};
        
        int index = findIndex(numbers, 400);
        if (index != -1) {
            System.out.println("Элемент 400 найден на индексе: " + index);  // 3
        }
    }
}

Использование List вместо массива

Для более гибкого управления часто используют List.

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // List более удобен чем массив
        List<Integer> numbers = new ArrayList<>();
        numbers.add(10);  // индекс 0
        numbers.add(20);  // индекс 1
        numbers.add(30);  // индекс 2
        numbers.add(40);  // индекс 3
        numbers.add(50);  // индекс 4

        // Безопаснее обращение
        if (numbers.size() > 3) {
            Integer value = numbers.get(3);  // 40
            System.out.println(value);
        }

        // Можно использовать stream
        Integer element = numbers.stream()
            .skip(3)
            .findFirst()
            .orElse(null);  // 40 или null
    }
}

Резюме

Если обратиться к элементу массива целых чисел с индексом 3:

1. Получишь 4-й элемент (индексирование начинается с 0)
2. Его значение зависит от инициализации:
   • Если не инициализирован - получишь 0 (default value для int)
   • Если инициализирован - получишь конкретное значение на этой позиции
3. Если индекс вне границ - выбросится ArrayIndexOutOfBoundsException
4. Всегда проверяй длину массива перед доступом
5. Лучше использовать List если нужна гибкость

Основная формула: array[i] возвращает i+1-й элемент массива (т.к. индексирование с 0).