import java.util.ArrayList;
ArrayList<String> list = new ArrayList<>();
// Добавление
list.add("apple"); // в конец
list.add(0, "banana"); // по индексу
// Доступ
list.get(0); // "banana"
list.size(); // 2
list.isEmpty(); // false
// Изменение
list.set(0, "mango"); // заменить по индексу
// Удаление
list.remove("apple"); // по значению
list.remove(0); // по индексу
// Поиск
list.contains("apple"); // true/false
list.indexOf("apple"); // индекс или -1
// Очистка
list.clear();
// Создание с начальными элементами
import java.util.List;
List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5));
// Сумма всех элементов
int sum = 0;
for (int n : nums) sum += n;
// Найти максимум
int max = nums.get(0);
for (int n : nums) if (n > max) max = n;
// Фильтрация (удалить чётные)
nums.removeIf(n -> n % 2 == 0);
// Сортировка
import java.util.Collections;
Collections.sort(nums); // по возрастанию
Collections.sort(nums, Collections.reverseOrder()); // убыв.
import java.util.LinkedList;
LinkedList<String> queue = new LinkedList<>();
queue.addFirst("a"); // в начало
queue.addLast("b"); // в конец
queue.add("c"); // в конец (то же)
queue.getFirst(); // "a" — не удаляет
queue.getLast(); // "c"
queue.removeFirst(); // "a" — удаляет и возвращает
queue.removeLast(); // "c"
Когда использовать:
- ArrayList — частое чтение по индексу
- LinkedList — частые вставки/удаления в начало/конец
import java.util.HashMap;
HashMap<String, Integer> map = new HashMap<>();
// Добавление / обновление
map.put("apple", 3);
map.put("banana", 5);
map.put("apple", 10); // перезапишет старое значение
// Чтение
map.get("apple"); // 10
map.get("missing"); // null
map.getOrDefault("x", 0); // 0 (если нет ключа)
// Проверки
map.containsKey("apple"); // true
map.containsValue(5); // true
map.size(); // 2
// Удаление
map.remove("banana");
// Перебор
for (String key : map.keySet()) {
System.out.println(key + " = " + map.get(key));
}
for (Map.Entry<String, Integer> e : map.entrySet()) {
System.out.println(e.getKey() + " = " + e.getValue());
}
// Подсчёт вхождений слов
String[] words = {"a", "b", "a", "c", "b", "a"};
HashMap<String, Integer> freq = new HashMap<>();
for (String w : words) {
freq.put(w, freq.getOrDefault(w, 0) + 1);
}
// {a=3, b=2, c=1}
import java.util.HashSet;
HashSet<String> set = new HashSet<>();
set.add("apple");
set.add("banana");
set.add("apple"); // дубликат — не добавится
set.size(); // 2
set.contains("apple"); // true
set.remove("apple");
// Перебор (порядок не гарантирован)
for (String s : set) {
System.out.println(s);
}
// Удалить дубликаты из списка
List<Integer> list = new ArrayList<>(List.of(1,2,2,3,3,3));
HashSet<Integer> unique = new HashSet<>(list);
// {1, 2, 3}
ArrayList — индексы, быстро get/set, медленно insert/delete в середину
LinkedList — быстро insert/delete в начало/конец, медленно get по индексу
HashMap — пары ключ-значение, быстро get/put/remove, без порядка
HashSet — уникальные элементы, быстро contains/add, без порядка
ArrayDeque — очередь/стек, быстро с обоих концов
List<String> list = List.of("a", "b", "c");
// 1. for-each (самый частый)
for (String s : list) { ... }
// 2. for с индексом
for (int i = 0; i < list.size(); i++) {
System.out.println(i + ": " + list.get(i));
}
// 3. Iterator
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String s = it.next();
}
// 4. forEach + лямбда
list.forEach(s -> System.out.println(s));
import java.util.Collections;
List<Integer> list = new ArrayList<>(List.of(3,1,4,1,5,9));
Collections.sort(list); // [1,1,3,4,5,9]
Collections.reverse(list); // [9,5,4,3,1,1]
Collections.shuffle(list); // перемешать случайно
Collections.min(list); // 1
Collections.max(list); // 9
Collections.frequency(list, 1); // 2 (сколько раз встречается)
Collections.fill(list, 0); // заполнить нулями
Collections.swap(list, 0, 1); // поменять местами
// Diamond <> — компилятор сам выводит тип
ArrayList<String> list = new ArrayList<>(); // не ArrayList<String>()
// var — полный вывод типа (Java 10+)
var map = new HashMap<String, Integer>();
var list2 = new ArrayList<String>();