Olá? Sou o Jayon.

Hoje, veremos o que é o JCF e quais são suas características.

O que é JCF?

JCF é a abreviação de Java Collections Framework, um conjunto de classes que fornece um método padronizado para processar dados em massa de forma fácil e eficaz. Em outras palavras, é a implementação de classes de estruturas de dados para armazenamento de dados e algoritmos para processamento de dados. Aqui, Collections são consideradas como um conjunto ou grupo de dados.

Framework vs Biblioteca

Um framework pode ser definido como 'um conjunto de classes e interfaces que trabalham juntas para resolver um problema específico de software', e não é uma aplicação completa, mas sim um trabalho a ser completado pelo programador. Por outro lado, uma biblioteca é um conjunto de ferramentas simples que podem ser usadas.

Para explicar a diferença entre os dois com mais detalhes, o framework controla o fluxo geral e o usuário insere o código necessário, enquanto o usuário cria o fluxo geral e usa a biblioteca.

Antecedentes da introdução do JCF

Antes da introdução do JCF, os métodos padronizados para agrupar objetos Java (Coleção) eram Arrays, Vectors e Hashtables, e essas Coleções não tinham nenhuma interface comum. Portanto, mesmo que a finalidade dessas Coleções fosse a mesma, elas tinham que ser definidas separadamente. Além disso, cada Coleção usava métodos, sintaxe e construtores diferentes, o que tornava difícil para os desenvolvedores usá-los.

// Java program to demonstrate 
// why collection framework was needed 
import java.io.*; 
import java.util.*; 
  
class CollectionDemo { 
  
    public static void main(String[] args) 
    { 
        // Creating instances of the array, 
        // vector and hashtable 
        int arr[] = new int[] { 1, 2, 3, 4 }; 
        Vector v = new Vector(); 
        Hashtable h 
            = new Hashtable(); 
  
        // Adding the elements into the 
        // vector 
        v.addElement(1); 
        v.addElement(2); 
  
        // Adding the element into the 
        // hashtable 
        h.put(1, "geeks"); 
        h.put(2, "4geeks"); 
  
        // Array instance creation requires [], 
        // while Vector and hastable require () 
        // Vector element insertion requires addElement(), 
        // but hashtable element insertion requires put() 
  
        // Accessing the first element of the 
        // array, vector and hashtable 
        System.out.println(arr[0]); 
        System.out.println(v.elementAt(0)); 
        System.out.println(h.get(1)); 
  
        // Array elements are accessed using [], 
        // vector elements using elementAt() 
        // and hashtable elements using get() 
    } 

Como mostrado no código acima, mesmo que o objetivo seja simplesmente inserir elementos, encontrá-los e exibi-los, a sintaxe usada para cada um é diferente. Por exemplo, ao inserir elementos, o vetor é addElement() e o Hashtable é put().

Portanto, os desenvolvedores Java projetaram uma interface comum para resolver esse problema, e é esse Java Collections Framework que apresentaremos hoje. Vale lembrar que, com o surgimento do JCF, o Vector e o Hashtabls tornaram-se classes legadas e não são mais usadas hoje em dia.

Vantagens do JCF

(1) Fácil de reutilizar o código.

(2) Fornece implementações de alto desempenho de estruturas de dados e algoritmos, melhorando o desempenho e a qualidade do programa.

(3) Fornece interoperabilidade entre APIs não relacionadas.

(4) Reduz o tempo necessário para aprender e projetar novas APIs.

(5) Promove a reutilização de software. Isso ocorre porque novas estruturas de dados que usam o JCF são reutilizáveis e, pelo mesmo motivo, novos algoritmos podem ser criados usando objetos que usam o JCF.

Resumo

Vimos o significado do JCF, por que ele foi introduzido e quais são suas vantagens.

Na próxima vez, abordaremos a hierarquia do JCF.