Какое ограничение не дает добавлять элементы в массив?

Ограничения при добавлении элементов в массив

Это критически важный вопрос о природе массивов в Java. Массивы имеют фиксированный размер, и это является главным ограничением.

Основное ограничение: Фиксированный размер

// При создании массива размер зафиксирован
int[] numbers = new int[5]; // Массив из 5 элементов

// Индексы: 0, 1, 2, 3, 4
numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;
numbers[3] = 40;
numbers[4] = 50;

// ❌ ОШИБКА: ArrayIndexOutOfBoundsException
numbers[5] = 60; // Индекс 5 не существует!

// length - это READ-ONLY поле
System.out.println(numbers.length); // 5
// numbers.length = 10; // ❌ ОШИБКА компиляции!

В памяти это выглядит так:

Массив: int[5]
┌───┬───┬───┬───┬───┐
│10 │20 │30 │40 │50 │
└───┴───┴───┴───┴───┘
 0   1   2   3   4  ← индексы

Попытка доступа к индексу 5:
numbers[5] = 60;
      ↓
ArrayIndexOutOfBoundsException!
(индекс 5 вне границ [0, 4])

Исключение при выходе за границы

public class ArrayBoundsExample {
    public static void main(String[] args) {
        int[] arr = new int[3];
        
        try {
            for (int i = 0; i <= 3; i++) { // i = 0,1,2,3
                arr[i] = i * 10;
                System.out.println("arr[" + i + "] = " + arr[i]);
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Ошибка: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

// Вывод:
// arr[0] = 0
// arr[1] = 10
// arr[2] = 20
// Ошибка: Index 3 out of bounds for length 3

Решение 1: Использовать List (динамическая коллекция)

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

// List автоматически растет по мере добавления элементов
List<Integer> numbers = new ArrayList<>();

numbers.add(10);  // index 0
numbers.add(20);  // index 1
numbers.add(30);  // index 2
numbers.add(40);  // index 3 - RESIZE автоматически!
numbers.add(50);  // index 4 - еще один RESIZE!

// Нет ошибок, size растет автоматически
System.out.println(numbers.size()); // 5

Как работает ArrayList внутри:

public class ArrayList<E> extends AbstractList<E> {
    private static final int DEFAULT_CAPACITY = 10;
    
    transient Object[] elementData; // Внутренний массив
    private int size; // Текущее количество элементов
    
    public boolean add(E e) {
        // Проверяем, нужно ли расширять
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;
        return true;
    }
    
    private void ensureCapacityInternal(int minCapacity) {
        if (minCapacity > elementData.length) {
            // Увеличиваем размер внутреннего массива
            grow(minCapacity);
        }
    }
    
    private void grow(int minCapacity) {
        // Новый размер = старый размер * 1.5 + 1
        int newCapacity = elementData.length + (elementData.length >> 1);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

// Процесс расширения:
// 1. Создается новый большой массив
// 2. Копируются все элементы старого массива
// 3. Новый массив становится elementData

Решение 2: Заранее выделить достаточно памяти

// Если известна максимальная длина, выделяй с запасом
int[] arr = new int[100]; // Достаточно для 100 элементов

int count = 0;
for (int i = 0; i < 50; i++) {
    arr[count++] = i; // Безопасно, есть место
}

// Используй только нужные элементы
System.out.println(Arrays.toString(Arrays.copyOf(arr, count)));

Решение 3: Копирование в больший массив

public class DynamicArray<T> {
    
    private Object[] elements;
    private int size = 0;
    private static final int INITIAL_CAPACITY = 10;
    
    public DynamicArray() {
        elements = new Object[INITIAL_CAPACITY];
    }
    
    public void add(T value) {
        if (size == elements.length) {
            // Массив полный, увеличиваем размер
            resize();
        }
        elements[size++] = value;
    }
    
    private void resize() {
        // Создаем новый массив большего размера
        Object[] newElements = new Object[elements.length * 2];
        
        // Копируем старые элементы
        System.arraycopy(elements, 0, newElements, 0, size);
        // или
        // newElements = Arrays.copyOf(elements, elements.length * 2);
        
        elements = newElements;
    }
    
    @SuppressWarnings("unchecked")
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return (T) elements[index];
    }
    
    public int size() {
        return size;
    }
}

// Использование
DynamicArray<Integer> arr = new DynamicArray<>();
for (int i = 1; i <= 25; i++) {
    arr.add(i); // Автоматически резайзится при необходимости
}

Сравнение: Массив vs ArrayList

// ❌ Массив - фиксированный размер
int[] staticArray = new int[10];
staticArray[10] = 100; // ArrayIndexOutOfBoundsException

// ✅ ArrayList - динамический размер
List<Integer> dynamicList = new ArrayList<>();
for (int i = 0; i < 100; i++) {
    dynamicList.add(i); // Безопасно, автоматически растет
}

Многомерные массивы имеют то же ограничение

// Двумерный массив
int[][] matrix = new int[3][4];

// Можно получить доступ к:
matrix[0][0] = 1;  // OK
matrix[2][3] = 12; // OK

// ❌ Но не к:
matrix[3][0] = 100; // ArrayIndexOutOfBoundsException
matrix[0][4] = 100; // ArrayIndexOutOfBoundsException

Проверка границ перед доступом

public class SafeArrayAccess {
    
    public static int safeGet(int[] arr, int index) {
        if (arr == null) {
            throw new IllegalArgumentException("Array is null");
        }
        if (index < 0 || index >= arr.length) {
            throw new IndexOutOfBoundsException(
                "Index " + index + " out of bounds for array of length " + arr.length
            );
        }
        return arr[index];
    }
    
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        
        try {
            System.out.println(safeGet(arr, 1));  // 20 - OK
            System.out.println(safeGet(arr, 5));  // Exception
        } catch (IndexOutOfBoundsException e) {
            System.out.println("Перехвачена ошибка: " + e.getMessage());
        }
    }
}

Лучшие практики

1. Используй List для неизвестного размера:

   List<String> names = new ArrayList<>();
   

2. Используй массив для известного, фиксированного размера:

   int[] coordinates = new int[3]; // x, y, z
   

3. Всегда проверяй границы:

   if (index >= 0 && index < array.length) {
       // Safe access
   }
   

4. Используй enhanced for loop чтобы избежать ошибок индексов:

   for (int value : array) { // Не нужно отслеживать индекс
       System.out.println(value);
   }
   

5. Для частых resize операций используй ArrayList с начальной ёмкостью:

   List<Integer> list = new ArrayList<>(1000); // Избежать промежуточных resize
   

Резюме

Главное ограничение: Массивы имеют фиксированный размер, установленный при создании. Попытка доступа к индексу вне границ [0, length-1] выбросит ArrayIndexOutOfBoundsException.

Для динамических коллекций используй List интерфейс и его реализации (ArrayList, LinkedList и т.д.), которые автоматически управляют размером и растут по мере необходимости.