☕ Вопросы интервью по Java

Ответ: Java не позволяет напрямую создавать generic массивы из-за type erasure (стирания типов). Generic типы проверяются во время компиляции, тогда как массивы выполняют проверку типа во время выполнения, что может привести к проблемам безопасности типов.

• Обобщение (Generics) проверяются во время компиляции, а массивы - во время выполнения
• Из-за type erasure, фактический generic тип недоступен во время выполнения
• Разрешение создания generic массивов могло бы привести к неожиданным ошибкам и нарушению безопасности типов

// ❌ Это вызовет ошибку компиляции
List<Integer>[] arr = new List<Integer>[10];

// ✅ Вместо этого используйте:
List<Integer>[] arr = new ArrayList[10];  // Но это не type-safe

// ✅ Или еще лучше:
List<List<Integer>> list = new ArrayList<>();
                

Ответ: Оба массивы и ArrayList хранят элементы в структуре похожей на контигуозную память, но они отличаются в том, как управляется размер. Массивы имеют фиксированный размер, тогда как ArrayList использует динамический внутренний массив, который может расти или сжиматься по мере необходимости.

• Хранят элементы в блоке памяти фиксированного размера, выделенном во время создания
• Все элементы находятся в последовательных ячейках памяти
• Размер нельзя изменить после создания

• Внутренне используют массив и автоматически создают больший массив, когда текущая емкость превышена
• Предоставляют динамическое изменение размера
• Менее память-эффективны чем массивы, потому что часто имеют дополнительную емкость

// Массив - фиксированный размер 5
int[] arr = new int[5];  // Может хранить только 5 элементов

// ArrayList - динамический размер
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
// ArrayList автоматически растет при добавлении элементов
                

Ответ: Существует несколько способов преобразования между ArrayList и Array в Java.

Программисты могут преобразовать Array в ArrayList, используя метод asList() класса Arrays. Это статический метод, который принимает объект List.

Arrays.asList(item)
                

String[] temp = { "Abc", "Def", "Ghi", "Jkl" };

// Преобразование массива в ArrayList
List<String> conv = Arrays.asList(temp);
System.out.println(conv);  // [Abc, Def, Ghi, Jkl]
                

List<String> list = new ArrayList<>();
list.add("one");
list.add("two");
list.add("three");

// Преобразование ArrayList в Array
String[] arr = list.toArray(new String[0]);

// Или используя метод toArray() без параметров
Object[] objArr = list.toArray();
                

Ответ: ArrayList растет динамически путем создания нового большего массива, когда текущая емкость становится полной. Затем все существующие элементы копируются из старого массива в новый массив, позволяя добавить дополнительные элементы.

• Внутренне ArrayList реализован с помощью изменяемого массива
• Когда массив полн, создается новый массив с большей емкостью
• Процесс изменения размера автоматический и прозрачный для программиста

ArrayList<Integer> list = new ArrayList<>();
// Начальная емкость обычно 10

list.add(1);
list.add(2);
// ... добавляем элементы

// Когда добавляется 11-й элемент, ArrayList создает новый массив
// большей емкости (обычно 1.5x или 2x от текущей) и копирует все элементы
list.add(11);  // Внутри произойдет resize
                

Когда ArrayList достигает своей емкости и добавляется новый элемент, Java создает новый массив с увеличенной емкостью (обычно в 1.5x), копирует все существующие элементы и удаляет ссылку на старый массив.

Ответ: Vector - это класс динамического массива в Java, который может расти или сжиматься автоматически, когда элементы добавляются или удаляются. Он похож на ArrayList, но синхронизирован, что делает его потокобезопасным.

• Хранит элементы в порядке вставки и позволяет дублирующиеся значения
• Автоматически изменяет размер при добавлении или удалении элементов
• Синхронизирован по умолчанию, что делает его подходящим для многопоточной среды
• Считается устаревшим классом в Java (legacy)

Vector<Integer> vec = new Vector<>();
vec.add(1);
vec.add(2);
vec.add(3);
                

Ответ: ArrayList можно сделать только для чтения, используя метод, предоставленный классом Collections, используя метод Collections.unmodifiableList().

array_readonly = Collections.unmodifiableList(ArrayList);
                

ArrayList<Character> temp = new ArrayList<>();
temp.add('X');
temp.add('Y');
temp.add('Z');

System.out.println("Initial list: " + temp);  
// Вывод: [X, Y, Z]

// Создание read-only списка
List<Character> readOnlyList = Collections.unmodifiableList(temp);

System.out.println("ReadOnly ArrayList: " + readOnlyList);
// Вывод: [X, Y, Z]

// Попытка добавить элемент вызовет UnsupportedOperationException
try {
    readOnlyList.add('A');
} catch (UnsupportedOperationException e) {
    System.out.println("Exception: " + e);
    // Вывод: Exception: java.lang.UnsupportedOperationException
}
                

Ответ: Priority Queue - это абстрактный тип данных, подобный обычной очереди или структуре данных стека. Элементы, хранящиеся в элементах, зависят от определенного приоритета от низкого к высокому. PriorityQueue основана на приоритетной кучи.

public interface PriorityQueue<E> extends Queue<E>
                

import java.util.*;

class PriorityQueueDemo {
    public static void main(String args[]) {
        // Создание пустой приоритетной очереди
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        
        // Добавление элементов
        pq.add(10);
        pq.add(20);
        pq.add(15);
        
        // Извлечение элемента с наивысшим приоритетом
        System.out.println(pq.peek());  // Вывод: 10
    }
}
                

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

Ответ: LinkedList - это класс Java, который использует двусвязный список для хранения элементов. Он наследует класс AbstractList и реализует интерфейсы List и Deque.

• LinkedList классы не синхронизированы
• Сохраняет порядок вставки
• Может использоваться как список, стек или очередь

LinkedList<String> list = new LinkedList<>();
list.add("Element 1");
list.add("Element 2");
list.remove(0);
                

Ответ: Класс Stack в Java - это структура данных LIFO (Last In First Out), которая наследует класс Vector, но имеет функции, специфичные для стека. Класс Stack в Java предоставляет следующие методы:

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);

System.out.println(stack.peek());   // Вывод: 30
System.out.println(stack.pop());    // Вывод: 30
System.out.println(stack.empty());  // Вывод: false
                

Ответ: Set - это коллекция в Collection Framework, которая не хранит дублирующихся элементов. Set не сохраняет никакой порядок элементов. Java Collections Framework предоставляет несколько реализаций интерфейса Set:

• HashSet: HashSet в Java хранит элементы в хеш-таблице, что обеспечивает более быстрые поиски и более быструю вставку. HashSet не упорядочен.
• LinkedHashSet: LinkedHashSet - это реализация HashSet, которая сохраняет порядок вставки элементов.
• TreeSet: TreeSet хранит элементы в отсортированном порядке, определяемом естественным упорядочиванием элементов или настраиваемым компаратором, предоставленным во время создания.

// HashSet пример
HashSet<String> hashSet = new HashSet<>();
hashSet.add("Apple");
hashSet.add("Banana");

// LinkedHashSet сохраняет порядок
LinkedHashSet<String> linkedSet = new LinkedHashSet<>();
linkedSet.add("Apple");
linkedSet.add("Banana");

// TreeSet сортирует элементы
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("Apple");
treeSet.add("Banana");