ArrayList es una array de tamaño variable de la interfaz de lista. Proporciona los métodos que se pueden usar para manipular el tamaño de la array cuando sea necesario.
Cada instancia de un ArrayList tiene cierta capacidad, la capacidad significa el tamaño para almacenar los elementos en el ArrayList. Si no asigna ninguna capacidad, la capacidad predeterminada es 10, pero si ingresa el elemento 11, aumentará automáticamente la capacidad de la array según sus requisitos, ya que la lista ArrayList es una lista ampliable.
Algunas operaciones de ArrayList como size(), isEmpty(), get(), set(), iterator() y ListIterator() se ejecutan en tiempo constante. La operación de agregar se ejecuta en n tiempo, n es la cantidad de veces que llama al método de agregar o la cantidad de veces que agrega el elemento en la array.
Constructores de ArrayList:
- ArrayList() : Inicialmente crea una ArrayList vacía.
- ArrayList(Collection <? extends E> c) : Crea una ArrayList que contiene los elementos de la colección dada.
Implementación de la API ArrayList:
Java
// Java Program to Implement ArrayList API
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Spliterator;
public class ArrayListIntegerExample {
public static void main(String[] args)
{
// Construct an ArrayList having default capacity 10
ArrayList<Integer> array = new ArrayList<>();
// ArrayList(Collection <? extends E> c)
ArrayList<Integer> arrayWithColl
= new ArrayList<Integer>(array);
// Add elements in array
array.add(100);
array.add(120);
array.add(500);
array.add(220);
array.add(150);
// Insert the elements in specified index
// array.add(index, element);
array.add(4, 50);
// Add all the elements together
// array.addAll(collection)
List<Integer> list;
list = new ArrayList<Integer>(Arrays.asList(90, 20, 40, 10, 15));
array.addAll(list);
// Add all the elements in specified index
// array.addAll(index, collection)
list = new ArrayList<Integer>(Arrays.asList(60, 25, 12, 16, 45));
array.addAll(2, list);
// Create shallow copy of array
ArrayList<Integer> array1;
array1 = array;
// Clear all the element from the list
array.clear();
// Check whether the particular element is present
// in the list or not array.contains(object)
array1.add(100);
array1.add(120);
array1.add(500);
array1.add(220);
array1.add(150);
System.out.println("Contains 120? : "
+ array1.contains(120)); // returns true
System.out.println("Contains 200? : "
+ array1.contains(200)); // returns false
// To ensure the minimum capacity of array
// ArrayList<E> arrayname = new ArrayList<E>(int
// minCapacity)
ArrayList<Integer> array2 = new ArrayList<Integer>(10);
// Iterate through the ArrayList
System.out.println();
System.out.println("Elements of the array using enhanced for-loop : ");
array.forEach(i -> System.out.print(i + " "));
System.out.println();
// Iterator
System.out.println("Elements of the array using iterator : ");
Iterator<Integer> itr = array.iterator();
while (itr.hasNext())
System.out.print(itr.next() + " ");
System.out.println();
// List Iterator
System.out.println("Elements of array using list - iterator : ");
ListIterator<Integer> itr1 = array.listIterator();
while (itr1.hasNext())
System.out.print(itr1.next() + " ");
System.out.println();
// Get the particular element from specified index
// array.get(index)
System.out.println("Element at index 2 is : "
+ array.get(2));
System.out.println();
// Get the position of particular element
// array.indexOf(object)
System.out.println("Element 500 is at index position : "
+ array.indexOf(500));
System.out.println();
// Check whether list is empty or not
System.out.println("Array is empty? "
+ array.isEmpty());
System.out.println();
// Get the last index of element in array
// array.lastIndexOf(object)
System.out.println("Last index of the element 100 is : "
+ array.lastIndexOf(100));
System.out.println();
// Remove the particular element
// array.remove(index)
System.out.println("Remove the element which is at index 3 : "
+ array.remove(3));
System.out.println();
// Remove all the elements together
// array.removeAll(collection)
array.removeAll(array);
// Remove all the elements of the collection
// if condition specified the given predicate
array1.add(100);
array1.add(120);
array1.add(500);
array1.add(220);
array1.add(150);
array1.add(123);
array1.add(233);
array1.add(111);
array1.removeIf(num -> (num % 3 == 0));
System.out.println("Array element after filtering : " + array1);
System.out.println();
// Retain all the elements
array1.retainAll(array);
System.out.println("Retain the array element : "
+ array1);
System.out.println();
// Set the element at particular index
array1.set(3, 999);
System.out.println();
// Display the size of arraylist
System.out.println("Size of the array is : "
+ array1.size());
System.out.println();
// Sort the list
Collections.sort(array1);
System.out.println("Array elements after sorting : "
+ array1);
System.out.println();
// Create a late-binding
Spliterator<Integer> split = array1.spliterator();
// characteristic
if (split.hasCharacteristics(Spliterator.ORDERED))
System.out.println("Ordered");
if (split.hasCharacteristics(Spliterator.SIZED))
System.out.println("Sized");
System.out.println();
// estimateSize() and getExactSizeIfKnown
System.out.println("Estimate size of arraylist is : "
+ split.estimateSize());
System.out.println("Exact size of array is : "
+ split.getExactSizeIfKnown());
System.out.println();
// trySplit
Spliterator<Integer> split1 = split.trySplit();
split.forEachRemaining(i -> System.out.println(i));
System.out.println("*****");
split1.forEachRemaining(i -> System.out.println(i));
System.out.println();
// Returns a sub-list within a specified index
System.out.println("Sub-list from the index position 1 to 3 : "
+ array1.subList(1, 3));
System.out.println();
// Returns an array that contain all elements
// public Object[] toArray()
Object[] o = array1.toArray();
System.out.println("ArrayList traversal using toArray method : "
+ Arrays.toString(o));
System.out.println();
// public <T> T[] toArray(T[] a)
Integer a[] = new Integer[array1.size()];
a = array1.toArray(a);
System.out.println(
"ArrayList traversal using toArray with argument method : "
+ Arrays.toString(a));
System.out.println();
// Trim the size to the number of elements
array1.trimToSize();
System.out.println("Array size after trimming : "
+ array1.size());
}
}
Producción
Contains 120? : true Contains 200? : false Elements of the array using enhanced for-loop : 100 120 500 220 150 Elements of the array using iterator : 100 120 500 220 150 Elements of array using list - iterator : 100 120 500 220 150 Element at index 2 is : 500 Element 500 is at index position : 2 Array is empty? false Last index of the element 100 is : 0 Remove the element which is at index 3 : 220 Array element after filtering : [100, 500, 220, 233] Retain the array element : [100, 500, 220, 233] Size of the array is : 4 Array elements after sorting : [100, 220, 500, 999] Ordered Sized Estimate size of arraylist is : 4 Exact size of array is : 4 500 999 ***** 100 220 Sub-list from the index position 1 to 3 : [220, 500] ArrayList traversal using toArray method : [100, 220, 500, 999] ArrayList traversal using toArray with argument method : [100, 220, 500, 999] Array size after trimming : 4
Publicación traducida automáticamente
Artículo escrito por snigdha_yambadwar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA