Какие знаешь методы для указания размера массива при его создании?

Методы указания размера массива при его создании

В Java существует несколько способов создания массивов с указанием размера. Это важно для оптимизации памяти и производительности.

1. Инициализация с явным размером

Самый прямой способ — указать размер при создании:

public class ArraySizeExample {
    public static void main(String[] args) {
        // Пустой массив размером 10
        int[] numbers = new int[10];
        // Значения по умолчанию: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        
        // Массив объектов размером 5
        String[] names = new String[5];
        // Значения по умолчанию: [null, null, null, null, null]
        
        // Массив boolean размером 3
        boolean[] flags = new boolean[3];
        // Значения по умолчанию: [false, false, false]
        
        // Размер может быть переменной
        int size = getUserInput();
        double[] temperatures = new double[size];
    }
    
    static int getUserInput() {
        return 100;
    }
}

Значения по умолчанию для разных типов:

public class DefaultValuesExample {
    public static void main(String[] args) {
        // Примитивные типы
        int[] intArray = new int[1];           // [0]
        long[] longArray = new long[1];        // [0L]
        double[] doubleArray = new double[1];  // [0.0]
        boolean[] boolArray = new boolean[1];  // [false]
        char[] charArray = new char[1];        // ['\u0000']
        
        // Ссылочные типы
        String[] stringArray = new String[1];  // [null]
        Object[] objectArray = new Object[1];  // [null]
    }
}

2. Инициализация с литеральными значениями

Создание и заполнение массива одновременно:

public class ArrayLiteralExample {
    public static void main(String[] args) {
        // Размер определяется количеством элементов
        int[] numbers = {10, 20, 30, 40, 50};  // Размер 5
        
        String[] fruits = {"apple", "banana", "orange"};  // Размер 3
        
        // Многомерные массивы
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };  // 3x3 матрица
        
        // С использованием new (явное указание)
        int[] nums = new int[]{1, 2, 3, 4, 5};
    }
}

3. Многомерные массивы

Для многомерных массивов нужно указать размеры каждого измерения:

public class MultidimensionalArrayExample {
    public static void main(String[] args) {
        // 2D массив (3 строки, 4 столбца)
        int[][] matrix = new int[3][4];
        // Размер: 3x4, всего 12 элементов
        
        // 3D массив (2x3x4)
        int[][][] cube = new int[2][3][4];
        // Размер: 2x3x4, всего 24 элемента
        
        // Массив массивов переменной длины (jagged array)
        int[][] jagged = new int[3][];
        jagged[0] = new int[2];  // Первая строка имеет 2 элемента
        jagged[1] = new int[3];  // Вторая строка имеет 3 элемента
        jagged[2] = new int[4];  // Третья строка имеет 4 элемента
    }
}

4. Копирование массивов с изменением размера

Если нужно изменить размер после создания:

public class ArrayResizingExample {
    public static void main(String[] args) {
        int[] original = {1, 2, 3, 4, 5};
        
        // Увеличение размера
        int[] enlarged = new int[10];
        System.arraycopy(original, 0, enlarged, 0, original.length);
        // Результат: [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
        
        // Или через Arrays.copyOf()
        int[] resized = Arrays.copyOf(original, 10);
        // Результат: [1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
        
        // Уменьшение размера
        int[] truncated = Arrays.copyOf(original, 3);
        // Результат: [1, 2, 3]
    }
}

5. Использование Collections для динамического размера

Если размер заранее неизвестен, лучше использовать Collections:

public class DynamicSizeExample {
    public static void main(String[] args) {
        // ArrayList — динамический массив
        ArrayList<Integer> list = new ArrayList<>();
        // Начальный capacity: 10
        
        // С явным начальным размером
        ArrayList<String> names = new ArrayList<>(20);
        // capacity: 20 (но size: 0)
        
        names.add("Alice");
        names.add("Bob");  // Увеличивает capacity автоматически при необходимости
        
        // LinkedList для частых вставок/удалений
        LinkedList<Integer> numbers = new LinkedList<>();
        
        // HashSet для уникальных значений
        HashSet<String> uniqueNames = new HashSet<>(16);
        // capacity: 16, load factor: 0.75
    }
}

6. Stream API для создания массивов

Создание массива из потока данных:

public class StreamArrayExample {
    public static void main(String[] args) {
        // Создание массива из stream
        int[] numbers = new int[]{1, 2, 3, 4, 5};
        int[] filtered = Arrays.stream(numbers)
            .filter(n -> n % 2 == 0)
            .toArray();  // Размер определяется автоматически
        // Результат: [2, 4]
        
        // С указанием типа массива
        int[] doubled = Arrays.stream(numbers)
            .map(n -> n * 2)
            .toArray();
        // Результат: [2, 4, 6, 8, 10]
        
        // Из List в массив
        List<String> list = Arrays.asList("a", "b", "c");
        String[] array = new String[list.size()];
        list.toArray(array);  // Заполняет существующий массив
    }
}

7. Инициализация с помощью конструктора

Для более сложных случаев используются вспомогательные методы:

public class ComplexInitializationExample {
    public static void main(String[] args) {
        // Массив последовательности чисел
        int[] sequence = new int[10];
        for (int i = 0; i < sequence.length; i++) {
            sequence[i] = i + 1;  // [1, 2, 3, ..., 10]
        }
        
        // Через IntStream
        int[] rangeArray = IntStream.range(1, 11).toArray();
        // Результат: [1, 2, 3, ..., 10]
        
        // Массив со значениями
        int[] filled = new int[10];
        Arrays.fill(filled, 5);  // [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
        
        // Массив с начальным значением из функции
        String[] repeated = new String[5];
        Arrays.setAll(repeated, i -> "Item " + i);
        // ["Item 0", "Item 1", "Item 2", "Item 3", "Item 4"]
    }
}

8. Варианты для объектов

public class ObjectArrayExample {
    static class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public static void main(String[] args) {
        // Массив объектов
        Person[] people = new Person[3];
        // [null, null, null]
        
        people[0] = new Person("Alice", 25);
        people[1] = new Person("Bob", 30);
        people[2] = new Person("Charlie", 35);
        
        // Инициализация объектов при создании
        Person[] initialized = {
            new Person("Alice", 25),
            new Person("Bob", 30),
            new Person("Charlie", 35)
        };
        
        // С использованием Stream
        Person[] fromStream = IntStream.range(0, 5)
            .mapToObj(i -> new Person("Person " + i, 20 + i))
            .toArray(Person[]::new);
    }
}

9. Производительность: Выделение памяти

public class MemoryPerformanceExample {
    public static void main(String[] args) {
        // Хорошая практика: выделить достаточно памяти сразу
        ArrayList<String> list1 = new ArrayList<>(10000);
        // Память выделяется на 10000 элементов
        // Затем при добавлении новых элементов capacity будет расширяться
        
        // Плохая практика: создавать без начального размера
        ArrayList<String> list2 = new ArrayList<>();
        // Capacity: 10
        // При добавлении > 10 элементов будут дорогие переаллокации
        
        // HashMap с инициальным размером
        HashMap<String, Integer> map = new HashMap<>(1000);
        // Рассчитан на 1000 элементов с load factor 0.75
    }
}

Сравнение подходов

Best Practices

public class ArrayCreationBestPractices {
    // 1. ✅ Используй явный размер, если он известен
    int[] array = new int[1000];
    
    // 2. ✅ Указывай начальный capacity для Collections
    ArrayList<String> list = new ArrayList<>(expectedSize);
    
    // 3. ✅ Используй ArrayList, если размер неизвестен
    List<Integer> dynamicList = new ArrayList<>();
    
    // 4. ✅ Используй Stream для трансформаций
    int[] result = sourceArray.stream()
        .filter(predicate)
        .toArray();
    
    // 5. ❌ Не создавай большие массивы без необходимости
    // 6. ✅ Используй Arrays.fill() для инициализации
    // 7. ✅ Используй Arrays.copyOf() для изменения размера
}

Вывод

Основные методы указания размера массива:

1. Явное указание: new int[10]
2. Литеральные значения: {1, 2, 3}
3. Arrays.copyOf(): изменение размера
4. Collections (ArrayList): динамический размер
5. Stream.toArray(): размер определяется из потока
6. Arrays.fill()/setAll(): инициализация значениями

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