Articolo
Inizia
Inizia il corso
JavaRush /Java Blog /Random-IT /ArrayList in Java
Зепп Бранниган
Livello 41

ArrayList in Java

Pubblicato nel gruppo Random-IT
Durante lo sviluppo, è spesso difficile prevedere la dimensione degli array necessari. Pertanto, la funzione di allocazione dinamica della memoria durante l'esecuzione del programma è necessaria per ogni linguaggio di programmazione. Un array dinamico è un array la cui dimensione può cambiare durante l'esecuzione del programma. In Java esiste una classe ArrayList a questo scopo .

Cos'è la classe ArrayList?

ArrayList è un'implementazione di array mutabile dell'interfaccia List, parte del Collection Framework, che è responsabile dell'elenco (o array dinamico) situato nel pacchetto java.utils. Questa classe implementa tutte le operazioni facoltative sugli elenchi e fornisce metodi per controllare la dimensione dell'array utilizzato per archiviare l'elenco. ArrayList si basa sull'idea di un array dinamico. Vale a dire, la possibilità di aggiungere e rimuovere elementi, aumentando o diminuendo secondo necessità.

Cosa memorizza ArrayList?

Fare riferimento solo a tipi e qualsiasi oggetto, incluse classi di terze parti. Stringhe, flussi di output, altre raccolte. Le classi wrapper vengono utilizzate per archiviare tipi di dati primitivi.

Costruttori ArrayList

  1. Lista di array()

    Costruttore vuoto con capacità iniziale dell'array interno = 10.

    ArrayList<String> list = new ArrayList<>();

    Si consiglia di indicare la tipologia dei valori memorizzati tra parentesi angolari. Nell'esempio sopra - String.

  2. ArrayList(Raccolta <? estende E> c)

    Il costruttore accetta un'altra raccolta, creando un nuovo array con gli elementi della raccolta passata:

    ArrayList<String> list2 = new ArrayList<>(list);

    L'ordine degli elementi nel nuovo elenco sarà lo stesso dell'originale.

  3. ArrayList(int capacitàiniziale)

    Il parametro del costruttore è il valore della dimensione iniziale dell'array interno.

    ArrayList<String> list2 = new ArrayList<>(10000);

    Se l'ArrayList sottostante esaurisce lo spazio quando vengono aggiunti nuovi elementi, viene creato un nuovo array più grande e i dati vengono copiati al suo interno. Se si sa in anticipo durante la scrittura del codice che nell'array verrà elaborato un numero elevato di elementi, è necessario specificare un valore maggiore per scopi di ottimizzazione.

Java-университет

Metodi ArrayList

    Di seguito sono riportati i metodi principali di ArrayList.

  • aggiungi(E e)

    Aggiunge un nuovo elemento alla fine dell'elenco. Restituisce boolean-value ( true - successo, false - non aggiunto):

    ArrayList<String> list = new ArrayList<>();
list.add("Hello");

  • add(int indice, elemento E)

    Aggiunge un elemento elementalla posizione indice. Durante l'aggiunta, tutti gli elementi a destra dell'indice specificato vengono spostati di 1 posizione a destra:

    list.add(0, "Amigo");

    Molto utile quando è necessario inserire un elemento in un punto qualsiasi di un elenco, ma per operazioni di inserimento frequenti all'inizio e al centro dell'ArrayList potrebbe non essere una buona scelta: dovresti consultare LinkedList.

  • addAll(Collezione <? estende E> raccolta)

    Aggiunge tutti gli elementi della raccolta a un elenco nell'ordine in cui appaiono nella raccolta.

  • addAll(int indice, Collezione <? estende E> collezione)

    Добавление всех элементов collection в список начиная с индекса index. При этом все элементы сдвинутся вправо на количество элементов в списке collection:

    ArrayList<String> secondList = new ArrayList<>();
secondList.addAll(list);
System.out.println("First addition: " + secondList);
secondList.addAll(1, list);
System.out.println("Second addition in the middle: " + secondList);

    Вывод:

    
Первое добавление: [Amigo, Hello]
Второе добавление в середину: [Amigo, Amigo, Hello, Hello]

    Методы addAll() также возвращают boolean-результат добавления элементов.

  • clear()

    Удаление всех элементов из списка.

  • clone()

    returns an object-копию массива:

    ArrayList<String> copyOfSecondList = (ArrayList<String>) secondList.clone();
secondList.clear();
System.out.println(copyOfSecondList);

    Вывод:

    
[Amigo, Amigo, Hello, Hello]

    Следует обратить внимание, что метод clone() возвращает Object, так что после его вызова потребуется сделать приведение к необходимому классу.

    При клонировании создается новый независимый an object. В примере показано, How очищение клонированного an object не сказалось на составе его клона.

  • contains(Object o)

    Проверка наличие an object в списке, возвращает boolean-meaning.

    System.out.println(copyOfSecondList.contains("Hello"));
System.out.println(copyOfSecondList.contains("Check"));

    Вывод:

    
true
false

  • ensureCapacity(int minCapacity)

    Увеличивает размер внутреннего массива, чтобы в него поместилось количество элементов, переданных в minCapacity. Если массив достаточно вместителен, ниHowие преобразования не производятся.

    Этот метод полезен, когда возникает потребность вместить большое количество элементов в несколько итераций. Например, при создании списка емкость его внутреннего массива — 10. При загрузке данных по сети они обрабатываются асинхронно порциями и результаты помещаются в массив. Если ожидается доставка 10 000 элементов, может быть неэффективно просто добавлять эти данные каждый раз: достаточно будет в начале обработки вызвать метод ensureCapaciry(10000) и записывать туда данные по мере необходимости.

  • forEach(Consumer<? super E> action)

    Обработать в цикле ArrayList можно стандартными способами, цикл for:

    // First way
for(int i = 0; i< secondList.size(); i++) {
   System.out.println(secondList.get(i));
}
И цикл for-each:
// Second way
for(String s : secondList) {
   System.out.println(s);
}

    В классе ArrayList есть метод для обработки каждого element, который называется также, forEach. В качестве аргумента передается реализация интерфейса Consumer, в котором нужно переопределить метод accept():

    secondList.forEach(new Consumer<String>() {
   @Override
   public void accept(String s) {
       System.out.println(s);
   }
});

    Вывод:

    
Amigo
Amigo
Hello
Hello

    Метод accept принимает в качестве аргумента очередной элемент того типа, который хранит в себе ArrayList. Пример для Integer:

    ArrayList<Integer> integerList = new ArrayList<>();
integerList.forEach(new Consumer<Integer>() {
   @Override
   public void accept(Integer integer) {
       System.out.println(integer);
   }
});

    Метод action() будет выполнен для каждого element.

  • get(int index)

    returns элемент, который расположен в указанной позиции списка.

    Если index < 0 or index >= максимального количества элементов списка, будет выброшено исключение IndexOutOfBoundsException.

    Это основной метод получения element из списка, время извлечения element по индексу всегда будет одинаковым, независимо от размера ArrayList.

  • indexOf(Object o)

    Метод возвращает индекс первого вхождения element в списке. Если element не существует в списке, метод вернет -1.

  • isEmpty()

    Метод возвращает true, если список пустой, false в обратном случае.

    Если в списке содержатся только элементы null, метод вернет false. Иными словами, null элементы также учитываются этим методом.

  • iterator()

    returns итератор для списка для последующего использования в цикле or при любой другой обработке.

    Итератор для ArrayList — fail-fast. Это значит, что если коллекция изменится во время итерации, будет выброшено исключение ConcurrentModificationException. Подробнее об fail-fast и его противоположности fail-safe можно почитать здесь.

  • lastIndexOf(Object o)

    Функционал метода похож на indexOf(), отличие в том, что возвращается индекс последнего element в списке.

    Если элемент не найден, также возвращает -1.

  • remove(int index)

    Удаление element в указанной позиции индекса. После удаления сдвигает все элементы влево для заполнения освободившегося пространства.

    Если index<0 or >= количество элементов списка, будет выброшено исключение IndexOutOfBoundsException. В результате метод возвращает элемент, который был удален.

  • remove(Object o)

    Метод удаляет из списка переданный элемент o. Если элемент присутствует в списке, он удаляется, а все элементы смещаются влево. Если элемент существует в списке и успешно удален, метод возвращает true, в обратном случае — false.

  • removeAll(Collection<?> c)

    Если необходимо удалить несколько элементов, не стоит делать это в цикле по условию: гораздо удобнее и безопаснее воспользоваться методом removeAll(). Он принимает коллекцию элементов, которая будет удалена из списка.

    Коллекция должна содержать элементы того же типа, которые хранит целевой список. В обратном случае будет выброшен ClassCastException. Метод вернет true, если список был изменен в результате вызова метода.

  • set(int index, E element)

    Замена element в указанной позиции index на переданный element. Индекс также должен быть больше нуля и меньше индекса последнего element, иначе будет выброшено исключение IndexOutOfBoundsException.

  • size()

    Лучший способ (практически единственный) для того, чтобы узнать размер массива.

  • sort(Comparator<? super E> c)

    Сортировка списка по заданному правилу. Правило сортировки представляет собой реализованный интерфейс Comparator с переопределенным методом compareTo().

    Переопределение нужно, если коллекция содержит an objectы собственного класса. При работе со стандартными классами (Integer, String и так далее) переопределение compareTo() требуется только для нестандартной сортировки.

  • toArray()

    Превращает список в фиксированный массив. Обратите внимание, что метод возвращает массив an objectов (Object[]). Если необходимо привести список в массив an objectов определенного типа, в качестве параметра в метод можно передать массив, куда будут перемещены элементы списков.

    Пример: 

    String[] array = new String[secondList.size()];
secondList.toArray(array);
for(int i = 0; i< array.length; i++) {
   System.out.println(array[i]);
}

    Вывод:

    
Amigo
Amigo
Hello
Hello
I metodi ArrayList in Java vengono appresi nel corso JavaRush. La prima conoscenza avviene al settimo livello della ricerca sulla sintassi Java, alla lezione “ArrayList Class” . Allo stesso livello ci sono raccolte di attività - uno e due , in cui è necessario utilizzare i metodi ArrayList, vengono forniti ulteriori esempi di lavoro con ArrayList e generici e viene spiegata la differenza tra ArrayList e LinkedList. Questo è un ampio argomento di studio, quindi, in una forma o nell'altra, Arraylist in Java (i metodi di questa classe sono solo una parte dell'intero corpus di conoscenze che vale la pena approfondire) viene restituito nel corso ai seguenti livelli della formazione - Core, Collections, Multithreading. Crediamo che la pratica quotidiana della scrittura del codice sia la chiave principale del successo nella programmazione. Pertanto, l'80% di JavaRush è costituito da attività pratiche, miniprogetti e attività di gioco. Tutto questo significa centinaia di ore di programmazione che ti aiuteranno a migliorare le tue abilità.

Collegamenti per ulteriori letture

  1. Un articolo dettagliato sugli array dinamici , o più precisamente su ArrayListe LinkedList, che svolgono il loro ruolo nel linguaggio Java.
  2. Un articolo sulla rimozione di elementi da un ArrayList .
  3. Lezione su come lavorare con ArrayList in diagrammi e immagini .
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION