JavaRush/Java блог/Java Developer/Класс ArrayList в Java
Автор
Владимир Портянко
Java-разработчик в Playtika

Класс ArrayList в Java

Статья из группы Java Developer
участников
Привет! В прошлых лекциях мы подробно разобрали такую структуру данных как массив и рассмотрели распространенные примеры работы с ними. Но у этой структуры данных есть ряд недостатков. Ответом на них в Java стало появление ArrayList. Если говорить максимально просто, то список ArrayList в Java — это “прокачанный” массив с большим количеством новых возможностей.Класс ArrayList - 1

Чем Java Arraylist отличается от обычных массивов?

Вообще, массивы — штука достаточно удобная и как ты уже заметил, с ними можно много чего делать :) Тем не менее, у массивов есть и ряд недостатков.
  • Ограниченный размер. Нужно уже на этапе создания массива знать, сколько ячеек он должен содержать. Недооценишь нужное количество — места не хватит. Переоценишь — массив останется полупустым, и это еще полбеды. Ведь получается, ты еще и выделишь под него больший объем памяти, чем нужно.
  • У массива нет методов для добавления элементов. Всегда приходится явно указывать индекс ячейки, куда нужно добавить элемент. Если нечаянно указать уже занятую ячейку с каким-то нужным значением, оно перезапишется.
  • Нет методов для удаления элемента. Значение можно только “обнулить”.
public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Томас");
       cats[1] = new Cat("Бегемот");
       cats[2] = new Cat("Филипп Маркович");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}
Вывод:

[Cat{name='Томас'}, null, Cat{name='Филипп Маркович'}]
Все эти недочеты можно устранить, используя ArrayList. Создается он очень просто:
ArrayList<Cat> cats = new ArrayList<Cat>();
Теперь мы создали список для хранения объектов Cat. Обрати внимание: мы не указываем размер ArrayList’a, поскольку он является автоматически расширяемым. Как такое возможно? Легко. Ты удивишься, но в основе ArrayList’a лежит самый обыкновенный массив :) Да, внутри у него находится массив, в котором и хранятся наши элементы. Но у ArrayList’a есть специальный механизм по работе с ним:
  • Когда этот внутренний массив заполняется, ArrayList создает внутри себя новый массив. Его размер = (размер старого массива * 1,5) +1.
  • Все данные копируются из старого массива в новый
  • Старый массив удаляется сборщиком мусора.
Благодаря этому механизму в ArrayList’e (в отличие от массива) реализован метод для добавления нового элемента. Это метод add().
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Бегемот"));
}
Новый элемент добавляется в конец списка. Теперь риска переполнения нет, поэтому такой механизм полностью безопасен. Кстати, ArrayList умеет не только искать объект по индексу, но и наоборот — может найти индекс объекта в ArrayList’e по ссылке на объект! Для этого в нем реализован метод indexOf(): Мы передаем в него ссылку на нужный объект, и indexOf() возвращает нам его индекс:
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}
Вывод:

0
Все верно, объект thomas действительно хранится в ячейке 0. У массивов есть не только недостатки, но и несомненные преимущества. Одно из них — поиск элемента по индексу. Поскольку мы указываем на индекс, то есть на конкретный адрес в памяти, такой поиск в массиве осуществляется очень быстро. ArrayList в Java тоже так умеет! Для этого в нем реализован метод get():
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}
Вывод:

Cat{name='Бегемот'}
Кроме того, можно легко узнать, содержит ли ArrayList какой-то конкретный объект, или нет. Это делается с помощью метода contains():
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.remove(pushok);
   System.out.println(cats.contains(pushok));
}
Метод проверяет содержится ли элемент во внутреннем массиве ArrayList’a, и возвращает результат в виде booleantrue или false. Вывод:

false
И еще важное по поводу вставки. ArrayList позволяет вставлять данные не только в конец массива, но и в любую ячейку по индексу. Для этого у него есть два метода:
  • add(int index, Cat element)
  • set(int index, Cat element)
В оба ты передаешь индекс ячейки, в которую нужно сделать вставку, и ссылку на сам объект. Разница в том, что вставка через set() затирает старое значение, хранящееся в ячейке. А вставка через add() сначала сдвигает все элементы начиная с [index] к концу массива, а в образовавшуюся пустую ячейку добавляет нужный тебе объект. Вот пример:
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, philipp);//Сейчас у нас список из 2 котов. Добавляем 3-го через set:

   System.out.println(cats.toString());
}
Вывод:

[[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Филипп Маркович'}, Cat{name='Бегемот'}]
У нас был список из 2 котов, мы вставили еще одного через метод set() в ячейку 0. В итоге старое значение, хранящееся в этой ячейке, было заменено на новое.
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, philipp);//Сейчас у нас список из 2 котов. Добавляем 3-го через add

   System.out.println(cats.toString());
}
А вот add() сработал иначе. Он сдвинул все элементы вправо и после этого записал новое значение в ячейку 0. Вывод:

[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Филипп Маркович'}, Cat{name='Томас'}, Cat{name='Бегемот'}]
Чтобы полностью очистить список, используется метод clear():
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.clear();

   System.out.println(cats.toString());
}
Вывод:

[]
Из списка было удалено все содержимое. Кстати, обрати внимание: в отличие от массивов, в ArrayList метод toString() переопределен и сразу выводит список в формате строки. В случае с массивами нам для этого приходилось использовать класс Arrays. И раз уж вспомнили о Arrays: в Java можно легко “переключаться” между массивом и ArrayList, то есть преобразовывать одно к другому. В классе Arrays для этого есть метод Arrays.asList(). С его помощью мы получаем содержимое массива в виде списка и передаем его в конструктор нашего ArrayList:
public static void main(String[] args) {

   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   Cat[] catsArray = {thomas, behemoth, philipp, pushok};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}
Вывод:

[Cat{name='Томас'}, Cat{name='Бегемот'}, Cat{name='Филипп Маркович'}, Cat{name='Пушок'}]
Можно сделать и наоборот — получить массив из объекта ArrayList. Для этого используется метод toArray():
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}
Обрати внимание: в метод toArray() мы передали пустой массив. Это не ошибка. Внутри класса ArrayList данный метод реализован таким образом, что передача пустого массива увеличивает его производительность. Пока просто запомни это на будущее (но передать какой-то конкретный размер тоже можно, будет работать). Кстати про размер. Текущий размер списка можно узнать при помощи метода size():
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}
Здесь важно понимать, что в отличии от свойства length массива, метод ArrayList.size() возвращает именно число элементов, а не изначальную вместимость, ведь ее мы при создании ArrayList не указываем. Кстати, указать ее в общем-то можно. У ArrayList есть соответствующий конструктор. Но его поведение в плане добавления новых элементов от этого не изменится:
public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);//создаем ArrayList с изначальной вместимостью 2


   Cat thomas = new Cat("Томас");
   Cat behemoth = new Cat("Бегемот");
   Cat philipp = new Cat("Филипп Маркович");
   Cat pushok = new Cat("Пушок");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}
Вывод в консоль:

4
Мы создали список на 2 элемента, но когда нам это понадобилось, он спокойно расширился. Другое дело, что если мы создали изначально очень маленький список, ему придется чаще проводить операцию расширения, а это затрачивает определенное количество ресурсов. В этой лекции мы почти не затронули процесс удаления элементов из ArrayList. Конечно, это не по причине забывчивости. Эта тема была выделена в отдельную лекцию, с которой ты сможешь ознакомиться дальше :)
Комментарии (229)
  • популярные
  • новые
  • старые
Для того, чтобы оставить комментарий Вы должны авторизоваться
{Java_Shark}
Уровень 15
14 марта, 05:31
Супер!!! Автору++
Anastasia Я зеленый новичок в изучаю с нуля
6 февраля, 10:04
Очень хорошая статья, спасибо!
Максим Li Java Developer
29 ноября 2023, 05:39
Отлично, отлично)
Димас
Уровень 19
3 сентября 2023, 10:40
Кто не понял про массив, размером 0: Преобразование списка ArrayList в массив Cat[] с использованием toArray(new Cat[0]) не означает удаление данных из списка. Фактически, это создает новый массив Cat[], который копирует элементы из списка ArrayList, и этот новый массив будет содержать те же элементы, что и исходный список, в том же порядке. Параметр toArray(new Cat[0]) используется для указания типа возвращаемого массива. В данном случае, он говорит методу toArray, что нужно создать массив типа Cat[]. Размер new Cat[0] фактически не имеет значения, так как метод toArray создаст новый массив с правильным размером, который соответствует количеству элементов в списке ArrayList. Если бы вы передали массив с желаемым размером, например, new Cat[cats.size()], метод toArray использовал бы этот массив и заполнил бы его элементами из списка. Но в данном случае использование new Cat[0] более эффективно, так как это просто создает новый массив, а размер массива будет установлен автоматически. Таким образом, после выполнения этой операции, у вас будет новый массив Cat[], который содержит те же элементы, что и ваш исходный список ArrayList<Cat>
Denis Gritsay
Уровень 35
21 сентября 2023, 11:23
это только запомнить, не логично, что мы пишем Cat[] catsArray = cats.toArray(new Cat[0]); но при это без дополнительных операций создается Array размером 0 и потом заполняется элементами из массива, какая команда указывает на последующее заполнение вновь созданного обьекта класса аррай элементами массива (в данном случае их 4) не понятно. Либо это "синтаксический сахар" ?
Димас
Уровень 19
21 сентября 2023, 15:59
Ага, запомнить, на практике пару раз встретишь и запомнишь на всю жизнь :)
Denis Gritsay
Уровень 35
21 сентября 2023, 16:05
получается внутри происходит заполнение автоматически?
Димас
Уровень 19
21 сентября 2023, 16:28
Судя по всему, да. То есть типо берется значение (размер коллекции) и на его основе создается массив - передавая в него значения из коллекции - ну я себе так объяснил :)
Denis Gritsay
Уровень 35
21 сентября 2023, 18:10
наверное чуваки из низкоуровневых языков недоумевают от таких вещей, вроде с++
Димас
Уровень 19
22 сентября 2023, 11:25
😅 наверняка)) ну джависты могут удивиться синтаксису Python, как там все проще и легче запомнить))
Dmitry Vidonov
Уровень 29
Expert
12 августа 2023, 09:42
Great job, Mr. Portyanko!
Alexander Rozenberg
Уровень 32
14 июля 2023, 11:43
fine
Увайс Программист 1С
4 июля 2023, 09:39
public static void main(String[] args) { ArrayList<Cat> cats = new ArrayList<>(); Cat thomas = new Cat("Томас"); // Вот здесь создали объекты класса Cat. 4 объекта Cat behemoth = new Cat("Бегемот"); Cat philipp = new Cat("Филипп Маркович"); Cat pushok = new Cat("Пушок"); cats.add(thomas); // Вот тут добавили созданные объекты в лист cats.add(behemoth); cats.add(philipp); cats.add(pushok); Cat[] catsArray = cats.toArray(new Cat[0]); // Зачем еще раз создавать новый объект, когда на индексе 0 уже есть ранее созданный? System.out.println(Arrays.toString(catsArray)); }
Rustam
Уровень 35
Student
20 июня 2023, 10:05
Совсем не понял эту строку кода, для чего прописывается (new Cat[0])?
Cat[] catsArray = cats.toArray(new Cat[0]);
Ilya Saratov
Уровень 25
21 июня 2023, 09:35
как я понял у листа так (скрыто в методах) реализовано преобразование от массива встроенного к текущему массиву. Размер можно и сразу задать вроде.
No Name
Уровень 32
8 июня 2023, 14:47
+ статья в копилку
Ислам
Уровень 33
30 мая 2023, 14:00
Nice