Для создания простых списков применяется интерфейс List, который расширяет функцональность интерфейса Collection. Некоторые наиболее часто используемые методы интерфейса List:
void add(int index, E obj): добавляет в список по индексу index объект obj
void addFirst(E obj): добавляет объект в начало списка
void addLast(E obj): добавляет объект в конец списка
boolean addAll(int index, Collection<? extends E> col): добавляет в список по индексу index все элементы коллекции col. Если в результате добавления список был изменен, то возвращается true, иначе возвращается false
E get(int index): возвращает объект из списка по индексу index
E getFirst(): возвращает первый элемент списка
E getLast(): возвращает последний элемент списка
int indexOf(Object obj): возвращает индекс первого вхождения объекта obj в список. Если объект не найден, то возвращается -1
int lastIndexOf(Object obj): возвращает индекс последнего вхождения объекта obj в список. Если объект не найден, то возвращается -1
ListIterator<E> listIterator (): возвращает объект ListIterator для обхода элементов списка
static <E> List<E> of(элементы): создает из набора элементов объект List
E remove(int index): удаляет объект из списка по индексу index, возвращая при этом удаленный объект
E removeFirst(): удаляет первый элемент из списка
E removeLast(): удаляет последний элемент из списка
E set(int index, E obj): присваивает значение объекта obj элементу, который находится по индексу index
void sort(Comparator<? super E> comp): сортирует список с помощью компаратора comp
List<E> subList(int start, int end): получает набор элементов, которые находятся в списке между индексами start и end
static <E> List<E>of(E... elements): возвращает неизменяемый список (тип java.util.ImmutableCollections$ListN), который содержит элементы elements.
По умолчанию в Java есть встроенная реализация этого интерфейса - класс ArrayList. Класс ArrayList представляет обобщенную коллекцию, которая наследует свою функциональность от класса AbstractList и применяет интерфейс List. Проще говоря, ArrayList представляет простой список, аналогичный массиву, за тем исключением, что количество элементов в нем не фиксировано.
ArrayList имеет следующие конструкторы:
ArrayList(): создает пустой список
ArrayList(Collection <? extends E> col): создает список, в который добавляются все элементы коллекции col.
ArrayList (int capacity): создает список, который имеет начальную емкость capacity
Емкость в ArrayList представляет размер массива, который будет использоваться для хранения объектов. При добавлении элементов фактически происходит перераспределение памяти - создание нового массива и копирование в него элементов из старого массива. Изначальное задание емкости ArrayList позволяет снизить подобные перераспределения памяти, тем самым повышая производительность.
Рассмотрим основные операции ArrayList. Создание списка:
import java.util.ArrayList; // импортируем класс
public class Program{
public static void main(String[] args) {
ArrayList<String> people = new ArrayList<String>();
}
}
Поскольку компилятор может сам вывести тип, то мы можем сократить определение:
ArrayList<String> people = new ArrayList<>(); // или так var people = new ArrayList<String>();
Для получения размера списка применяется метод size(), который возвращает значение типа int:
var people = new ArrayList<String>(); System.out.println(people.size()); // 0
Для добавления применяется метод add(), в который передается добавляемый элемент:
var people = new ArrayList<String>();
people.add("Tom");
people.add("Bob");
people.add("Sam");
System.out.println(people.size()); // 3
Кроме того, с помощью перегрузки метода add() мы можем добавить элемент на определенную позицию в списке:
var people = new ArrayList<String>();
people.add("Tom");
people.add("Bob");
people.add("Sam");
people.add(1, "Alice"); // добавляем элемент по индексу 1
System.out.println(people.size()); // 4
В выражении people.add(1, "Alice") мы добавляем строку "Alice" в список по индексу 1.
Стоит отметить, что при создании ArrayList выделяется начальная область памяти, которая по умолчанию вмещает 10 элементов списка. Например, в коде выше при создании списка для него
выделяется область памяти, достаточная для вмещения 10 строк String. Если мы будем добавлять большее количество строк, то будут происходить повторные выделения памяти для вмещения новых объектов.
Поскольку выделения памяти на низком уровне - довольно затратный процесс, то, если мы заранее знаем сколько у нас будет объектов в списке или знаем по крайней мере максимальное количество объектов,
то рекомендуется это количество передавать в конструктор при создании объекта ArrayList. Например, создадим список, у которого начальная емкость равна 16 объектам:
var people = new ArrayList<String>(16); System.out.println(people.size()); // 0
Причем важно, что емкость списка и его размер - это не одно и то же. Так, в данном случае при создании списка выделяется область для хранения 16 объектов, однако пока она пуста и содержит 0 объектов. Тем не менее, когда мы будем добавлять 11-й элемент, не будет происходить дополнительного выделения памяти, потому что необходимая память уже выделена. Что в итоге увеличит производительность.
Либо это можно сделать с помощью метода ensureCapacity:
people.ensureCapacity(25);
Добавлять в список по одному элементу может быть не очень удобно, особенно когда надо добавить множество элементов. Но Java предоставляет ряд способов для добавления набора элементов. Прежде всего
интерфейс List определяет статический метод of(), в который можно передать произвольное количество объектов:
import java.util.List;
public class Program{
public static void main(String[] args) {
// создаем список из 3 строк
List<String> people = List.<String>of("Tom", "Bob", "Sam");
System.out.println(people.size()); // 3
}
}
В данном случае переменная people представляет интерфейс List<String>. В реальности эта переменная представляет тип
java.util.ImmutableCollections$ListN - внутренний класс Java, который представляет неизменяемый список фиксированной длины. Подобный список может быть полезен в некоторых ситуациях, но в данном случае
мы говорим об ArrayList - изменяемом списке произвольного размера. И для его создания мы можем использовать конструктор:
import java.util.List;
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
ArrayList<String> people = new ArrayList<String>(List.<String>of("Tom", "Bob", "Sam"));
System.out.println(people.size()); // 3
}
}
Из других доступных способов можно отметить статический метод Collections.addAll():
static <T> boolean addAll(Collection<? super T> c, T... elements)
Первый параметр - коллекция, в которую надо добавить данные, а второй - добавляемые объекты. Применение:
import java.util.Collections;
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>();
Collections.addAll(people, "Tom", "Bob", "Sam");
System.out.println(people.size()); // 3
}
}
В данном случае нам не надо создавать для добавляемых объектов отдельную коллекцию.
Для получения элементов списка применяется метод get(), в который передается индекс элемента:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>(16);
System.out.println(people.size()); // 0
people.add("Tom");
people.add("Bob");
people.add("Sam");
people.add(1, "Alice"); // добавляем элемент по индексу 1
System.out.println(people.get(0)); // Tom
System.out.println(people.get(1)); // Alice
System.out.println(people.get(2)); // Bob
System.out.println(people.get(3)); // Sam
}
}
Для перебора списка можно использовать традиционный цикл for:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>(16);
System.out.println(people.size()); // 0
people.add("Tom");
people.add("Bob");
people.add("Sam");
people.add(1, "Alice"); // добавляем элемент по индексу 1
for(int i =0; i < people.size(); i++){
System.out.println(people.get(i));
}
}
}
Или цикл for в стиле for-each:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>(16);
System.out.println(people.size()); // 0
people.add("Tom");
people.add("Bob");
people.add("Sam");
people.add(1, "Alice"); // добавляем элемент по индексу 1
for(String person : people){
System.out.println(person);
}
}
}
Для изменения элемента применяется метод set(int index, E obj), где первый параметр представляет индекс элемента для изменения, а второй - помещаемый по этому индексу объект:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>(16);
System.out.println(people.size()); // 0
people.add("Tom");
people.add("Bob");
people.add("Sam");
people.set(1, "Alex"); // изменяем элемент по индексу 1
System.out.println(people.get(1)); // Alex
}
}
Нередко бывает, что нам надо узнать индекс определенного элемента, то применяются методы indexOf(Object obj) (для первого индекса в списке) и lastIndexOf(Object obj) для последнего индекса:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>();
people.add("Tom");
people.add("Bob");
people.add("Tom");
people.add("Sam");
System.out.println(people.indexOf("Tom")); // 0
System.out.println(people.lastIndexOf("Tom")); // 2
}
}
Для удаления элементов применяется метод remove(Object obj), в который передается удаляемый объект:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var people = new ArrayList<String>();
people.add("Tom");
people.add("Bob");
people.add("Sam");
people.remove("Bob"); // удаляем элемент "Bob"
for(String person : people){
System.out.println(person); // Tom
// Sam
}
}
}
Консольный вывод:
Tom Sam
Но метод remove() имеет и другую версию, в которую передается индекс удаляемого элемента - remove(int index).
И тут может возникнуть вопрос, что будет, если у нас список чисел, и нам надо удалить какое-либо число. Например:
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var numbers = new ArrayList<Integer>();
numbers.add(11);
numbers.add(12);
numbers.add(13);
numbers.remove(12); // пытаемся удалить элемент 12
for(Integer n : numbers){
System.out.println(n);
}
}
}
Данная программа завершится с ошибкой, поскольку при передаче числа в метод remove() это число будет восприниматься как индекс, а не как элемент. И при вызове
numbers.remove(12) программа будет пытаться удалить элемент по индексу 12, которого в принципе не существует. И в этом случае надо будет сначала найти индекс удаляемого значения, а затем удалить его:
numbers.remove(numbers.indexOf(12)); // удаляем элемент 12
Еще один метод - removeIf() позволяет удалить все элементы, которые соответствуют некоторому предикату - условию. Например:
import java.util.Collections;
import java.util.ArrayList;
public class Program{
public static void main(String[] args) {
var numbers = new ArrayList<Integer>();
Collections.addAll(numbers, 1, 2, 3, 4, 5, 6, 7, 8);
numbers.removeIf( num -> num % 2 == 0);
for(var n : numbers) System.out.print(n + ", "); // 1, 3, 5, 7,
System.out.println();
}
}
В метод removeIf() передается условие в виде функции, которая получает каждый элемент списка и возвращает true, если этот элемент соответствует некоторому условию. В данном случае удаляем все четные
числа, то есть если при делении числа на 2 остаток равен 0:
numbers.removeIf( num -> num % 2 == 0);