Dúvida sobre CONJUNTOS - Estrutura de dados - Aula 7

Olá Frank,

Vejamos. O ArrayList denominado "tabela" é criado já no momento da definição do atributo - private ArrayList<LinkedList<String>> tabela = new ArrayList<LinkedList<String>>(); .. No momento em que a classe que detém esse atributo for instanciada, você já terá o esse objeto instanciado/disponível e sua referência na variável "tabela".

Em relação ao List dentro do metodo adiciona:

List<String> lista = tabela.get(indice);

Nesse caso perceba que dentro do método apenas usamos o ArrayList que foi criado (citado acima) e através dele chamamos o método get para pegar uma referência em determinada posição.

Acontece que isoladamente essa lista ainda não foi adicionada àtabela. Lembre-se que quando instanciamos uma array, uma lista, etc, ainda não temos nenhuma referência dentro delas. Todas suas posições inicialmente são nulas. Portanto, pensando só nesse trecho de código, o método adiciona(String palavra) só funciona com sucesso em casos onde já haja LinkedLists (listas) adicionadas ao ArrayList tabela.

A questão da adição das listas na tabela provavelmente está ocorrendo fora deste método, talvez até como responsabilidade de algum método específico.

Espero ter ajudado no pensamento. Abraço!

Obrigado Rafael Rollo, mas minha dúvida é exatamente sobre essa parte "A questão da adição das listas na tabela provavelmente está ocorrendo fora deste método, talvez até como responsabilidade de algum método específico."

Isso que está me deixando com a dúvida, "Em que momento essa "lista" está colocando dentro de "tabela".

Vou enviar todo o código da CLASSE "Conjunto"

public class Conjunto {


    private ArrayList<LinkedList<String>> tabela = new ArrayList<LinkedList<String>>();            // Aqui cria uma LinkedList que só aceita outra LinkedList<String>

    //CONSTRUTOR
    public Conjunto(){
        for(int i = 0; i < 26; i++){
            tabela.add(new LinkedList<String>());                        
        }                                                                
    }


    //MÉTODOS
    public void remove(String palavra){
        if(contemPalavra(palavra)){
            int indice = calculaIndiceDaTabela(palavra);
            List<String> lista = tabela.get(indice);                            
            lista.remove(palavra);                                        

        }
    }


public void adiciona(String palavra){                                
        if(!contemPalavra(palavra)){                                    
            int indice = calculaIndiceDaTabela(palavra);                
                                                                        /

            List<String> lista = tabela.get(indice);                                
            lista.add(palavra);                                            
        }                                                                // 
    }


    private int calculaIndiceDaTabela(String palavra) {
        return palavra.toLowerCase().charAt(0) % 26;                    
    }                                                                    

    private boolean contemPalavra(String palavra){
        int indice = calculaIndiceDaTabela(palavra);

        return tabela.get(indice).contains(palavra);                    
    }

    @Override
    public String toString() {
        return tabela.toString();                                        //(F6) Usa o "toString" do Linke
    }

Acredito que tiver uma ideia de como está sendo feito, está confuso, mas acredito ter entendido.

• LEMBRANDO QUE:

  • 1.1 List lista = tabela.get(indice); ==> Agora "lista" carrega o "LinkedList" que foi buscado com o "tabela.get(indice);"

  • 1.2 E quando é feito "Lista.add(palavra)" está dizendo que a lista(tabela.get(indice)) vai adicionar dentro dela (que no caso é o LinkedList puxado atráves do código "tabela.get(indice)")

Olá Frank,

Repare no trecho a seguir:

//CONSTRUTOR
public Conjunto(){
    for(int i = 0; i < 26; i++){
        tabela.add(new LinkedList<String>());
    }
}

Analisando a classe como um todo já da pra entender como está funcionando.

Antes de falar sobre o construtor, lembre-se do trecho private ArrayList<LinkedList<String>> tabela = new ArrayList<LinkedList<String>>(); - declaração de variável de instância já inicializada - que garante que quando você der new em Conjunto já tera o ArrayList tabela.

Agora sim, após isso, repare que o construtor de Conjunto executa uma lógica. Ele itera através de um laço de repetição 26 vezes, e em cada uma delas, adiciona uma LinkedList (lista) dentro de tabela. Sendo assim, quando você instancia a classe Conjunto você já tem a tabela criada, e 26 listas, uma em cada posição da tabela.

Cada operação de adição, remoção (etc) de palavras, funcionam perfeitamente, pois as estruturas de dados já estão prontas.

Espero ter ajudado. Abraço!

Muito obrigado pela ajuda.