¿Qué es Java Collection Framework?

El marco Ans Java Collection es una potente biblioteca integrada que proporciona un conjunto de implementaciones optimizadas de las estructuras de datos y algoritmos más utilizados. Se utiliza ampliamente para crear aplicaciones Java y resolver el desarrollo de software del mundo real. desafíos.

¿Cuáles son las ventajas de Java Collection Framework?

Respuesta Algunas de las ventajas del marco Java Collection son

1. Arquitectura unificada: cada estructura de datos se deriva de interfaces como la interfaz iterable y la interfaz de colección, lo que proporciona una sensación de implementaciones comunes.
2. Facilidad de uso: simplifica el proceso de desarrollo al proporcionar estructuras de datos y algoritmos prediseñados. El desarrollador puede centrarse más en la lógica empresarial en lugar de implementar y optimizar manualmente estructuras de datos y algoritmos estándar de uso común.
3. Flexibilidad: si queremos cambiar las estructuras de datos subyacentes, podemos hacerlo fácilmente sin preocuparnos de que cambiar la estructura de datos cambie los patrones de acceso y recuperación de datos (principalmente).
4. Seguridad de subprocesos: como Java proporciona una forma de ejecutar procesos en diferentes subprocesos individualmente, Java Collection Framework proporciona diferentes clases para ejecutar en entornos multiproceso y aplicaciones de un solo subproceso.

JERARQUÍA DEL MARCO DE COLECCIÓN JAVA

INTERFAZ ITERABLE
La interfaz Iterable en Java es un componente clave del Collection Framework. Es la interfaz raíz para todos los tipos de colecciones sobre las que se puede iterar. La implementación de la interfaz Iterable permite que un objeto sea el objetivo de un "bucle para cada" (también conocido como bucle for mejorado).
También proporciona un objeto iterador que se puede utilizar para la iteración directa de todas las estructuras de datos que implementan esta interfaz iterable.

Ejemplo de uso de FOR EACH LOOP (MEJORADO FOR LOOP)

Internamente ArrayList implementa List y List Interface extiende Collection Interface y Collection Interface extiende Iterable Interface.

List list = new ArrayList();//Declarando una estructura de datos
list.add("Java");//Agregar elemento
list.add("Colecciones");//Agregar elemento
list.add("Framework");//Agregar elemento
for (elemento de cadena: lista) {// Iteración usando el bucle for mejorado
System.out.println(elemento);
}

Ejemplo usando objeto ITERABLE

Iterador iterador = lista.iterador();
mientras (iterator.hasNext()) {
Elemento de cadena = iterador.next();
System.out.println(elemento);
}

Por lo tanto, podemos crear un iterable personalizado implementando una interfaz iterable y anulando el método next, hasNext y remove. Aquí hay un ejemplo de lo mismo.

import java.util.Iterator;
class CustomIterable implements Iterable {
    private final int[] numbers = {1, 2, 3, 4, 5};

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;
            private int lastReturnedIndex = -1;

            @Override
            public boolean hasNext() {
                return index 



Nota :


Los iteradores en Java son rápidos. Esto significa que si la colección se modifica durante la iteración (excepto a través del método remove() del propio iterador), arroja una excepción ConcurrentModificationException.
El método remove() solo puede eliminar elementos y debe llamarse solo una vez por llamada a next(). De lo contrario, arrojará una IllegalStateException.






  
  
  Interfaz de colección


Esta es la interfaz a través de la cual las estructuras de datos y las implementaciones internas se vuelven flexibles. Principalmente todas las clases implementan esta interfaz indirectamente, lo que permite cambiar la implementación simplemente cambiando el objeto asignado a la referencia de Colección.



//ArrayList
Collection c = new ArrayList():
c.add(1);
c.add(2);
c.contains(1);

Collection c1 = new LinkedList():
c1.addAll(c);//Array added to a linked list

/*What if i dont want arraylist but now i want a priority queue for applying efficient algorithms such as findmax and find min*/
//Just Change Object - SIMPLE!
Collection c = new **PriorityQueue**():
c.add(1);
c.add(2);
c.contains(1);




Métodos de interfaz de recopilación



int size: Devuelve el tamaño de la colección.

boolean isEmpty: Devuelve verdadero si la colección está vacía.

booleano contiene (Objeto o): devuelve verdadero si el Objeto o existe en la colección.

Iterador iterador(): Devuelve un iterador que apunta a una colección.

Object[] toArray(): convierte una colección en una matriz de tipo objeto.

 T[] toArray(T[] a): Devuelve una matriz que contiene todos los elementos de la colección; el tipo de tiempo de ejecución de la matriz devuelta es el de la matriz especificada.

boolean add(E e): Agrega el elemento e a la colección. Devuelve verdadero si la operación se realiza correctamente.

boolean remove(Object o): elimina un objeto o de la colección. Devuelve verdadero si la operación se realiza correctamente.

boolean containsAll(Collection> c) ​​: Devuelve verdadero si todos los elementos de ambas colecciones son iguales. Devuelve verdadero si la operación es exitosa.
10.boolean addAll(Collection extends E> c): Agrega todos los elementos de ambas colecciones. Devuelve verdadero si la operación se realiza correctamente.

boolean removeAll(Collection> c): elimina el elemento de la colección c de la colección de la persona que llama. Devuelve verdadero si la operación se realiza correctamente.

boolean retenciónAll(Collection> c): retiene sólo los elementos presentes en la colección c.

void clear() : Borra todos los elementos de la colección.


Al implementar la clase de colección, podemos anular los métodos anteriores para crear una colección personalizada. A continuación se muestra un ejemplo del mismo.



import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomCollection implements Collection {
    private final ArrayList list = new ArrayList();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return list.contains(o);
    }

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index  T[] toArray(T[] a) {
        return list.toArray(a);
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }

    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }

    @Override
    public boolean containsAll(Collection> c) {
        return list.containsAll(c);
    }

    @Override
    public boolean addAll(Collection extends E> c) {
        return list.addAll(c);
    }

    @Override
    public boolean removeAll(Collection> c) {
        return list.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection> c) {
        return list.retainAll(c);
    }

    @Override
    public void clear() {
        list.clear();
    }
}









  
  
  Interfaz de lista


La interfaz Lista en Java es parte del marco de colecciones de Java y amplía la interfaz de la colección. Representa una colección ordenada (también conocida como secuencia) que permite acceso posicional, elementos duplicados e iteración sobre sus elementos. La interfaz List se implementa mediante varias clases, como ArrayList, LinkedList, Vector y Stack.

Características clave de la interfaz de lista:


Colección ordenada: una lista conserva el orden de inserción de los elementos, lo que significa que se puede acceder a los elementos mediante su índice.
Permite duplicados: una lista puede contener elementos duplicados, a diferencia de los conjuntos que no permiten duplicados.
Acceso posicional: Se puede acceder a los elementos de una lista, agregarlos o eliminarlos mediante su índice.
Iteración: la interfaz List permite bucles for mejorados, así como iteración usando Iterator o ListIterator.


Métodos de interfaz de lista más utilizados:

Todos los métodos de la interfaz de colección también se implementan mediante la interfaz de Lista, ya que la interfaz de Lista extiende la interfaz de Colección.


void add(int index, elemento E): inserta el elemento E especificado en el índice especificado en esta lista.
E get(int index): Devuelve el elemento en la posición especificada en esta lista.
E remove(int index): elimina el elemento en la posición especificada en esta lista.
E set(int index, elemento E): reemplaza el elemento en la posición especificada en esta lista con el elemento especificado.
int indexOf(Object o): Devuelve el índice de la primera aparición del elemento especificado, o -1 si la lista no contiene el elemento.
int lastIndexOf(Object o): Devuelve el índice de la última aparición del elemento especificado, o -1 si la lista no contiene el elemento.
List subList(int fromIndex, int toIndex): devuelve una vista de la parte de esta lista entre el fromIndex, incluido y el toIndex, exclusivo especificados.



import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Java");
        list.add("Collections");
        list.add("Framework");

        // Accessing elements by index
        System.out.println("First Element: "   list.get(0));

        // Removing an element by index
        list.remove(1);
        System.out.println("After Removal: "   list);

        // Updating an element
        list.set(1, "Updated Element");
        System.out.println("Updated List: "   list);

        // Using a sublist
        List sublist = list.subList(0, 1);
        System.out.println("Sublist: "   sublist);
    }
}