Que O que é Java Collection Framework?

Ans Java Collection framework é uma poderosa biblioteca integrada que fornece um conjunto de implementações otimizadas das estruturas de dados e algoritmos mais comumente usados. É amplamente utilizado na construção de aplicativos Java e na solução de desenvolvimento de software do mundo real desafios.

Quais vantagens do Java Collection Framework?

Res Algumas das vantagens da estrutura Java Collection são

1. Arquitetura Unificada : Cada estrutura de dados é derivada de interfaces como interface iterável e interface de coleção, fornecendo uma sensação de implementações comuns.
2. Facilidade de uso: simplifica o processo de desenvolvimento, fornecendo estruturas de dados e algoritmos pré-construídos. O desenvolvedor pode se concentrar mais na lógica de negócios em vez de implementar e otimizar manualmente estruturas de dados e algoritmos padrão comumente usados.
3. Flexibilidade : Se quisermos alterar as estruturas de dados subjacentes, podemos fazê-lo facilmente, sem nos preocuparmos com o fato de que a alteração da estrutura de dados alterará a recuperação de dados e os padrões de acesso (principalmente).
4. Thread Safety : Como java fornece uma maneira de executar processos em diferentes threads individualmente, Java Collection Framework fornece diferentes classes para execução em ambientes multithread e aplicativos de thread único.

HIERARQUIA DA ESTRUTURA DE COLEÇÃO JAVA

INTERFACE ITERÁVEL
A interface Iterable em Java é um componente chave do Collection Framework. É a interface raiz para todos os tipos de coleção que podem ser iterados. A implementação da interface Iterable permite que um objeto seja o alvo de um "loop for-each" (também conhecido como loop for aprimorado).
Também fornece um objeto iterador que pode ser usado para iteração direta de todas as estruturas de dados que implementam esta interface iterável.

Exemplo usando FOR EACH LOOP (ENHANCED FOR LOOP)

Internamente ArrayList implementa Lista e Interface de Lista estende Interface de Coleção e Interface de Coleção estende Interface Iterável.

List list = new ArrayList();//Declarando uma estrutura de dados
list.add("Java");//Adicionar elemento
list.add("Coleções");//Adicionar elemento
list.add("Framework");//Adicionar elemento
for (String element : list) {//Iterando usando loop for aprimorado
System.out.println(elemento);
}

Exemplo usando objeto ITERÁVEL

Iterador iterador = list.iterator();
enquanto (iterador.hasNext()) {
Elemento de string = iterator.next();
System.out.println(elemento);
}

Assim, podemos criar uma interface iterável de implementação iterável personalizada e substituir os métodos next, hasNext e remove. Aqui está um exemplo do mesmo.

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 



Observação :

Iteradores em Java são à prova de falhas. Isso significa que se a coleção for modificada durante a iteração (exceto por meio do método remove() do próprio iterador), ela lançará uma ConcurrentModificationException.
O método remove() só pode remover elementos e deve ser chamado apenas uma vez por chamada para next(). Caso contrário, lançará uma IllegalStateException.

  
  
  Interface de coleção


Esta é a interface através da qual as estruturas de dados e implementações internas se tornam flexíveis. Principalmente todas as classes implementam esta interface indiretamente, permitindo alterar a implementação apenas alterando o objeto atribuído à referência da coleção dela.

 //ArrayList
Coleção c = new ArrayList():
c.add(1);
c.add(2);
c.contém(1);

Coleção c1 = new LinkedList():
c1.addAll(c);//Array adicionado a uma lista vinculada

/*E se eu não quiser arraylist, mas agora quiser uma fila de prioridade para aplicar algoritmos eficientes, como findmax e find min*/
//Apenas Mude o Objeto - SIMPLES!
Coleção c = new **PriorityQueue**():
c.add(1);
c.add(2);
c.contém(1);
//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 interface de coleção




int size : Retorna o tamanho da coleção.


boolean isEmpty: Retorna verdadeiro se a coleção estiver vazia.


boolean contém (Object o): Retorna verdadeiro se o Objeto o existir na coleção.


Iterator iterator() : Retorna um iterador apontando para uma coleção.


Object[] toArray() : Converte uma coleção em um array do tipo Object.


 T[] toArray(T[] a) : Retorna um array contendo todos os elementos da coleção; o tipo de tempo de execução da matriz retornada é o da matriz especificada.


boolean add(E e): Adiciona o elemento e à coleção. Retorna verdadeiro se a operação for bem-sucedida.


boolean remove(Object o): Remove um objeto o da coleção. Retorna verdadeiro se a operação for bem-sucedida.


boolean containsAll(Collection> c) ​​: Retorna verdadeiro se todos os elementos em ambas as coleções forem iguais. Retorna verdadeiro se a operação for bem-sucedida.
10.boolean addAll(Collection extends E> c) : Adiciona todos os elementos de ambas as coleções. Retorna verdadeiro se a operação for bem-sucedida.


boolean removeAll(Collection> c) ​​: Remove o elemento da coleção c da coleção do chamador. Retorna verdadeiro se a operação for bem-sucedida.


boolean retenAll(Collection> c) ​​: Retém apenas os elementos presentes na coleção c.


void clear(): Limpa todos os elementos da coleção.



Ao implementar a classe de coleção, podemos substituir os métodos acima para criar uma coleção personalizada. Abaixo está um exemplo do mesmo.


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

classe pública CustomCollection implementa Collection {
    private final ArrayList list = new ArrayList();

    @Substituir
    public int tamanho() {
        retornar lista.size();
    }

    @Substituir
    public boolean isEmpty() {
        retornar lista.isEmpty();
    }

    @Substituir
    público booleano contém (Objeto o) {
        retornar lista.contains(o);
    }

    @Substituir
    iterador público iterador() {
        retornar novo Iterador() {
            índice interno privado = 0;

            @Substituir
            público booleano hasNext() {
                índice de retorno  T[] toArray(T[] a) {
        retornar lista.toArray(a);
    }

    @Substituir
    adição booleana pública (E e) {
        retornar lista.add(e);
    }

    @Substituir
    public boolean remove(Objeto o) {
        retornar lista.remove(o);
    }

    @Substituir
    public boolean contémAll(Coleção> c) ​​{
        retornar lista.containsAll(c);
    }

    @Substituir
    public boolean addAll(Coleção estende E> c) {
        retornar lista.addAll(c);
    }

    @Substituir
    public boolean removeAll(Coleção> c) ​​{
        retornar lista.removeAll(c);
    }

    @Substituir
    public boolean reterAll(Coleção> c) ​​{
        retornar lista.retainAll(c);
    }

    @Substituir
    público vazio claro() {
        lista.claro();
    }
}

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();
    }
}



Interface de lista


A interface List em Java faz parte do Java Collections Framework e estende a interface Collection. Representa uma coleção ordenada (também conhecida como sequência) que permite acesso posicional, elementos duplicados e iteração sobre seus elementos. A interface List é implementada por diversas classes, como ArrayList, LinkedList, Vector e Stack.


Principais características da interface da lista:


Coleção ordenada: uma lista preserva a ordem de inserção dos elementos, o que significa que os elementos podem ser acessados ​​por seu índice.

Permite duplicatas: uma lista pode conter elementos duplicados, ao contrário de conjuntos que não permitem duplicatas.

Acesso posicional: os elementos de uma lista podem ser acessados, adicionados ou removidos por seu índice.

Iteração: A interface List permite loops for aprimorados, bem como iteração usando Iterator ou ListIterator.



Métodos comumente usados ​​de interface de lista:

Todos os métodos de interface de coleção também são implementados pela interface List, pois a interface List estende a interface Collection.


void add(int index, E element): Insere o elemento especificado E no índice especificado nesta lista.

E get(int index): Retorna o elemento na posição especificada nesta lista.

E remove(int index): Remove o elemento na posição especificada nesta lista.

E set(int index, E element): Substitui o elemento na posição especificada nesta lista pelo elemento especificado.

int indexOf(Object o): Retorna o índice da primeira ocorrência do elemento especificado, ou -1 se a lista não contém o elemento.

int lastIndexOf(Object o): Retorna o índice da última ocorrência do elemento especificado, ou -1 se a lista não contém o elemento.

List subList(int fromIndex, int toIndex): Retorna uma visualização da parte desta lista entre o fromIndex especificado, inclusive, e o toIndex, exclusivo.



importar java.util.ArrayList;
importar java.util.List;

classe pública ListExample {
    public static void main(String[] args) {
        Lista lista = new ArrayList();
        lista.add("Java");
        list.add("Coleções");
        list.add("Estrutura");

        // Acessando elementos por índice
        System.out.println("Primeiro Elemento: " list.get(0));

        // Removendo um elemento por índice
        lista.remove(1);
        System.out.println("Após a remoção: "lista);

        //Atualizando um elemento
        list.set(1, "Elemento Atualizado");
        System.out.println("Lista Atualizada: "lista);

        //Usando uma sublista
        Lista sublista = list.subList(0, 1);
        System.out.println("Sublista: " sublista);
    }
}

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);
    }
}