Списки в Java: основные типы и эффективные методы работы

// Создание пустого ArrayList
List<String> stringList = new ArrayList<>();

// Создание с начальной емкостью
List<Integer> numberList = new ArrayList<>(20);

// Создание LinkedList
List<Double> linkedScores = new LinkedList<>();

// С помощью factory методов (неизменяемые)
List<String> names = List.of("Alice", "Bob", "Charlie");

// Создание из существующей коллекции
ArrayList<String> copyList = new ArrayList<>(names);

// Через Arrays.asList (backed by array)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Использование Collections.singletonList
List<String> singleItem = Collections.singletonList("Single Element");

// Пустые неизменяемые списки
List<Integer> emptyList = Collections.emptyList();

// Создание через Stream
List<Integer> squareNumbers = IntStream.rangeClosed(1, 10)
.map(n -> n * n)
.boxed()
.collect(Collectors.toList());

// Преобразование массива в список
String[] array = {"Java", "Python", "C++"};
List<String> languages = Stream.of(array).collect(Collectors.toList());

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

// Добавление элемента в конец списка
fruits.add("Apple"); // [Apple]

// Добавление с указанием индекса
fruits.add(0, "Banana"); // [Banana, Apple]

// Добавление коллекции элементов
fruits.addAll(Arrays.asList("Orange", "Mango")); // [Banana, Apple, Orange, Mango]

// Добавление коллекции с указанием начального индекса
fruits.addAll(1, Arrays.asList("Cherry", "Grapes")); // [Banana, Cherry, Grapes, Apple, Orange, Mango]

// Удаление по индексу
String removed = fruits.remove(0); // removed = "Banana", fruits = [Cherry, Grapes, Apple, Orange, Mango]

// Удаление по значению (первое вхождение)
boolean isRemoved = fruits.remove("Cherry"); // true, fruits = [Grapes, Apple, Orange, Mango]

// Удаление элементов, соответствующих условию (Java 8+)
fruits.removeIf(fruit -> fruit.startsWith("M")); // [Grapes, Apple, Orange]

// Удаление коллекции элементов
fruits.removeAll(List.of("Apple", "Orange")); // [Grapes]

// Удаление всех элементов, кроме указанных
fruits.add("Pineapple");
fruits.add("Watermelon");
fruits.retainAll(List.of("Grapes", "Watermelon")); // [Grapes, Watermelon]

// Очистка списка
fruits.clear(); // []

List<Integer> numbers = new ArrayList<>(List.of(1, 2, 3, 4, 5));

// Небезопасный способ (вызовет исключение)
// for (Integer number : numbers) {
// if (number % 2 == 0) {
// numbers.remove(number);
// }
// }

// Безопасный способ через итератор
Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
Integer number = iterator.next();
if (number % 2 == 0) {
iterator.remove();
}
}
// numbers = [1, 3, 5]

// Или с помощью removeIf (Java 8+)
numbers.add(2);
numbers.add(4);
numbers.removeIf(n -> n % 2 == 0); // [1, 3, 5]

// Создаем тестовый список
List<String> languages = new ArrayList<>(
Arrays.asList("Python", "Java", "JavaScript", "C++", "Kotlin", "Go")
);

// 1. Сортировка с использованием Collections.sort() (естественный порядок)
Collections.sort(languages);
System.out.println("Натуральная сортировка: " + languages);
// Результат: [C++, Go, Java, JavaScript, Kotlin, Python]

// 2. Сортировка с компаратором (по длине строки)
Collections.sort(languages, Comparator.comparingInt(String::length));
System.out.println("Сортировка по длине: " + languages);
// Результат: [Go, C++, Java, Python, Kotlin, JavaScript]

// 3. Сортировка через List.sort() (Java 8+)
languages.sort(Comparator.reverseOrder());
System.out.println("Обратная сортировка: " + languages);
// Результат: [Python, Kotlin, JavaScript, Java, Go, C++]

// 4. Цепочка компараторов
languages.sort(
Comparator.comparing(String::length)
.thenComparing(Comparator.naturalOrder())
);
System.out.println("Комбинированная сортировка: " + languages);
// Результат: [Go, C++, Java, Kotlin, Python, JavaScript]

List<Integer> numbers = new ArrayList<>(
Arrays.asList(10, 20, 30, 40, 50, 60, 40, 30, 20, 10)
);

// 1. Проверка наличия элемента
boolean hasThirty = numbers.contains(30); // true

// 2. Поиск индекса первого вхождения
int firstIndex = numbers.indexOf(20); // 1

// 3. Поиск индекса последнего вхождения
int lastIndex = numbers.lastIndexOf(20); // 8

// 4. Бинарный поиск (список должен быть отсортирован!)
Collections.sort(numbers);
int position = Collections.binarySearch(numbers, 40); // 6

// 5. Поиск с использованием Stream API
boolean anyGreaterThan50 = numbers.stream().anyMatch(n -> n > 50); // true
boolean allLessThan100 = numbers.stream().allMatch(n -> n < 100); // true
Integer firstGreaterThan35 = numbers.stream()
.filter(n -> n > 35)
.findFirst()
.orElse(null); // 40

// Пример поиска объектов с кастомными классами
class Person {
private String name;
private int age;

// конструкторы, геттеры, сеттеры...

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}

@Override
public int hashCode() {
return Objects.hash(name, age);
}
}

List<Person> people = new ArrayList<>();
// заполнение списка...

// Поиск персоны
Person searchTarget = new Person("John", 30);
boolean found = people.contains(searchTarget); // работает корректно благодаря equals()

public class LRUCache<K, V> {
private final int capacity;
private final Map<K, V> cache = new HashMap<>();
private final LinkedList<K> usageOrder = new LinkedList<>();

public LRUCache(int capacity) {
this.capacity = capacity;
}

public V get(K key) {
if (!cache.containsKey(key)) {
return null;
}

// Обновляем позицию ключа (переносим в конец)
usageOrder.remove(key);
usageOrder.addLast(key);

return cache.get(key);
}

public void put(K key, V value) {
if (cache.containsKey(key)) {
usageOrder.remove(key);
} else if (cache.size() >= capacity) {
K leastUsed = usageOrder.removeFirst();
cache.remove(leastUsed);
}

cache.put(key, value);
usageOrder.addLast(key);
}
}

public class BatchProcessor<T> {
private final int batchSize;
private final List<T> items = new ArrayList<>();
private final Consumer<List<T>> processor;

public BatchProcessor(int batchSize, Consumer<List<T>> processor) {
this.batchSize = batchSize;
this.processor = processor;
}

public void add(T item) {
items.add(item);
if (items.size() >= batchSize) {
processBatch();
}
}

public void addAll(Collection<T> newItems) {
// Обрабатываем полные партии сразу
int itemsToAdd = newItems.size();
Iterator<T> iterator = newItems.iterator();

while (itemsToAdd > 0) {
int freeSpace = batchSize – items.size();
if (freeSpace == 0) {
processBatch();
continue;
}

int itemsToTake = Math.min(freeSpace, itemsToAdd);
for (int i = 0; i < itemsToTake; i++) {
if (iterator.hasNext()) {
items.add(iterator.next());
itemsToAdd--;
}
}

if (items.size() >= batchSize) {
processBatch();
}
}
}

public void processBatch() {
if (!items.isEmpty()) {
List<T> batch = new ArrayList<>(items);
items.clear();
processor.accept(batch);
}
}

public void flush() {
processBatch();
}
}

// Использование:
BatchProcessor<String> logger = new BatchProcessor<>(100, batch -> {
// Отправка пакета логов на сервер
System.out.println("Sending batch of " + batch.size() + " logs");
});

for (int i = 0; i < 350; i++) {
logger.add("Log entry " + i);
}
logger.flush();

public static <T, R> List<R> processInParallel(
List<T> items,
Function<T, R> processor,
int threads) {

if (items.isEmpty()) return Collections.emptyList();

int batchSize = Math.max(1, items.size() / threads);
List<List<T>> batches = new ArrayList<>();

for (int i = 0; i < items.size(); i += batchSize) {
int endIndex = Math.min(i + batchSize, items.size());
batches.add(items.subList(i, endIndex));
}

List<R> results = Collections.synchronizedList(new ArrayList<>(items.size()));

batches.parallelStream().forEach(batch -> {
List<R> batchResults = batch.stream()
.map(processor)
.collect(Collectors.toList());
results.addAll(batchResults);
});

return results;
}

// Использование:
List<String> urls = Arrays.asList(/* список URL */);
List<WebPage> pages = processInParallel(urls, this::downloadPage, 10);

public class UndoManager<T> {
private final LinkedList<T> undoStack = new LinkedList<>();
private final LinkedList<T> redoStack = new LinkedList<>();
private final int capacity;

public UndoManager(int capacity) {
this.capacity = capacity;
}

public void addState(T state) {
undoStack.push(state);
if (undoStack.size() > capacity) {
undoStack.removeLast();
}
redoStack.clear(); // После нового действия redo больше невозможен
}

public T undo() {
if (undoStack.isEmpty()) {
return null;
}

T currentState = undoStack.pop();
redoStack.push(currentState);
return undoStack.isEmpty() ? null : undoStack.peek();
}

public T redo() {
if (redoStack.isEmpty()) {
return null;
}

T state = redoStack.pop();
undoStack.push(state);
return state;
}

public boolean canUndo() {
return undoStack.size() > 1; // Нужен хотя бы один предыдущий + текущий
}

public boolean canRedo() {
return !redoStack.isEmpty();
}
}

public class LazyDataProvider<T> {
private final int pageSize;
private final Function<Integer, List<T>> dataLoader;
private final List<T> buffer = new ArrayList<>();
private int totalItems = -1;
private int lastLoadedPage = -1;

public LazyDataProvider(int pageSize, Function<Integer, List<T>> dataLoader) {
this.pageSize = pageSize;
this.dataLoader = dataLoader;
}

public T getItem(int index) {
int page = index / pageSize;

if (page != lastLoadedPage) {
buffer.clear();
List<T> pageData = dataLoader.apply(page);
buffer.addAll(pageData);
lastLoadedPage = page;

// Если это последняя страница с неполными данными
if (pageData.size() < pageSize) {
totalItems = page * pageSize + pageData.size();
}
}

int bufferIndex = index % pageSize;
return bufferIndex < buffer.size() ? buffer.get(bufferIndex) : null;
}

public boolean hasMoreItems(int index) {
return totalItems == -1 || index < totalItems;
}
}

// Использование:
LazyDataProvider<User> userProvider = new LazyDataProvider<>(
100,
page -> userRepository.findUsers(page, 100)
);

for (int i = 0; hasMoreItems(i); i++) {
User user = userProvider.getItem(i);
// Обработка пользователя
}