Lista Java

O Java Collection Framework contém interfaces e classes muito úteis que os implementam para trabalhar com estruturas de dados. Pode-se dizer que este é um dos frameworks JDK mais importantes. A interface List é muito popular. porque sem todos os tipos de listas na programação é indispensável. Neste artigo, abordaremos essa interface, os métodos e implementações da Lista Java.

Interface de Lista Java

A coisa mais importante sobre uma lista é que ela é uma coleção ordenada . Você também pode chamá-lo de uma sequência. Em Java, as listas são homogêneas, ou seja, os elementos da lista são do mesmo tipo de dados. A interface Java List herda de Collection, ela herda todas as suas operações. Além delas, também são possíveis as seguintes operações na Lista:

• Acesso posicional. Cada elemento possui um índice e pode ser manipulado com base em sua posição. na lista. Ou seja, você pode adicionar, excluir e modificar elementos.
• Procurar. Você pode encontrar um elemento em uma lista por seu conteúdo e retornar seu índice.
• Iteração. A natureza sequencial de List permite o uso de métodos de iteração (listIterator).
• Exibição de alcance. O método sublist executa operações de intervalo arbitrárias na lista.

Métodos de Lista Java

As operações acima são expostas nos métodos da interface Java List. Aqui estão alguns deles:

Implementação de lista

Como List é uma interface, os programas precisam criar uma implementação concreta dela. Você pode escolher entre as seguintes implementações de lista na API de coleções Java:

• java.util.ArrayList
• java.util.LinkedList
• java.util.Vector
• java.util.Stack

A implementação mais popular da interface List chamada ArrayList. Com muito menos frequência, mas você ainda pode ver o uso de LinkedList em tarefas reais, mas Vector e Stack se tornaram moralmente obsoletos por um longo tempo, então você provavelmente os encontrará apenas em projetos com código legado antigo.

Listar Declaração de Interface

Você pode declarar um programa List in Java de uma das seguintes maneiras:

List<String> myList = new ArrayList();
List myList1 = new ArrayList();
List myList3 = new ArrayList<String>();
ArrayList arrayList = new ArrayList();

É melhor declarar uma nova lista por meio de uma interface. Da mesma forma, você pode declarar outras implementações de List. O caminho mais curto:

Vector myVector = new Vector;
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();

Com essa declaração, o tipo de dados dos elementos dessas listas é determinado durante a inicialização da lista, ou seja, quando os elementos são adicionados a ela.

List myList = new ArrayList<String>();
Vector myVector = new Vector();
LinkedList linkedList = new LinkedList();
Stack stack = new Stack();
stack.add("Paul");
linkedList.add(1);
myVector.add(1.2f);
myList.add('a');

Agora, apenas strings podem ser adicionadas à nossa pilha, inteiros a linkedList , floats a myVector e myList é uma lista de caracteres.

Como funciona o ArrayList

Se você já está familiarizado com arrays regulares, também está um pouco familiarizado com ArrayList. Na verdade, ArrayList é um array dinâmico e dentro dele está um array comum. Essa matriz atua como um armazenamento de dados. ArrayList armazena apenas tipos de referência, quaisquer objetos, incluindo classes de terceiros, strings, fluxos de saída e outras coleções. As classes wrapper são usadas para armazenar tipos de dados primitivos em ArrayList. Ao criar uma lista, podemos definir imediatamente seu tamanho, mas na maioria dos casos não. Por padrão, o tamanho do ArrayList = 10. Como é adicionar um novo elemento a um ArrayList? Antes de tudo, é iniciada uma verificação para ver se há espaço suficiente no array interno e se cabe mais um elemento. Se houver espaço, o novo elemento é adicionado ao final da lista, ou seja, na célula que segue o último elemento. Seu índice será arraylist.size(). Se acabamos de criar nossa lista e ela está vazia, isso significa que arrayList.size() = 0. Assim, um novo elemento será adicionado à célula com índice 0. Se não houver espaço suficiente, um novo array é criado dentro do ArrayList com o tamanho (o tamanho do OldArray * 1.5) + 1. Pelo mesmo princípio, uma inserção ocorre no meio da lista, mas ao mesmo tempo, todos os elementos que seguem o elemento inserido são deslocado para a direita. Portanto, se tivermos 5 elementos na matriz e precisarmos inserir um elemento na célula número 2 (ou seja, a terceira), então 0 e 1 elementos da matriz permanecem no lugar, um novo elemento aparece na célula 2 e seu antecessor vai para a terceira célula e assim por diante. um novo elemento será adicionado à célula com índice 0. Se não houver espaço suficiente, uma nova matriz será criada dentro do ArrayList com o tamanho (o tamanho do OldArray * 1,5) + 1. Pelo mesmo princípio, uma inserção ocorre no meio da lista, mas, ao mesmo tempo, todos os elementos que seguem o elemento inserido são deslocados para a direita. Portanto, se tivermos 5 elementos na matriz e precisarmos inserir um elemento na célula número 2 (ou seja, a terceira), então 0 e 1 elementos da matriz permanecem no lugar, um novo elemento aparece na célula 2 e seu antecessor vai para a terceira célula e assim por diante. um novo elemento será adicionado à célula com índice 0. Se não houver espaço suficiente, uma nova matriz será criada dentro do ArrayList com o tamanho (o tamanho do OldArray * 1,5) + 1. Pelo mesmo princípio, uma inserção ocorre no meio da lista, mas, ao mesmo tempo, todos os elementos que seguem o elemento inserido são deslocados para a direita. Portanto, se tivermos 5 elementos na matriz e precisarmos inserir um elemento na célula número 2 (ou seja, a terceira), então 0 e 1 elementos da matriz permanecem no lugar, um novo elemento aparece na célula 2 e seu antecessor vai para a terceira célula e assim por diante. ocorre uma inserção no meio da lista, mas ao mesmo tempo todos os elementos que seguem o elemento inserido são deslocados para a direita. Portanto, se tivermos 5 elementos na matriz e precisarmos inserir um elemento na célula número 2 (ou seja, a terceira), então 0 e 1 elementos da matriz permanecem no lugar, um novo elemento aparece na célula 2 e seu antecessor vai para a terceira célula e assim por diante. ocorre uma inserção no meio da lista, mas ao mesmo tempo todos os elementos que seguem o elemento inserido são deslocados para a direita. Portanto, se tivermos 5 elementos na matriz e precisarmos inserir um elemento na célula número 2 (ou seja, a terceira), então 0 e 1 elementos da matriz permanecem no lugar, um novo elemento aparece na célula 2 e seu antecessor vai para a terceira célula e assim por diante.

Exemplo de Lista Java (realização de Arraylist)

import java.util.*;

public class ArrayListExample2 {
   public static void main(String[] args) {
       List<String> myFriendsList = new ArrayList();
       //we created list of some objects 
       System.out.println( "the size of myList before init = " + myFriendsList.size());
       myFriendsList.add("Alex");
       myFriendsList.add("Tanya");
       myFriendsList.add("Veloxy");
       myFriendsList.add("Alex");
       myFriendsList.add("Andrew");
       System.out.println(myFriendsList);
       System.out.println( "the size of myList after init = " + myFriendsList.size());

       myFriendsList.add("Ihor");
       System.out.println(myFriendsList);
       System.out.println("the size of my list = " +  myFriendsList.size());


       //here the program will print out the first appearance of "Alex" element
       System.out.println(myFriendsList.indexOf("Alex"));
       //program will print out the first appearance of "Alex" element starting from the element 0

       myFriendsList.remove(3);
       System.out.println(myFriendsList.get(3));
       System.out.println("after removing one of Alex's there is only one Alex: " + myFriendsList);
       System.out.println(myFriendsList.get(1));



       myFriendsList.clear();
       System.out.println("the size of the vector after clear method = " +  myFriendsList.size());

   }
}

Aqui está a saída deste programa:

Como funciona o LinkedList

Em uma LinkedList, os elementos são, na verdade, links na mesma cadeia. Cada elemento, além dos dados que armazena, possui um link para o elemento anterior e o seguinte. Esses links permitem que você navegue de um elemento para outro. O iterador suporta passagem em ambas as direções. Implementa métodos para obter, remover e inserir no início, meio e fim de uma lista. Permite adicionar quaisquer elementos, incluindo null. LinkedList implementa duas interfaces — não apenas List, mas também Deque. Isso fornece a capacidade de criar uma fila bidirecional de qualquer elemento, mesmo nulo. Cada objeto colocado na lista encadeada é um nó (nó). Cada nó contém um elemento, um link para o nó anterior e o seguinte. Na verdade, a lista encadeada consiste em uma sequência de nós, cada um dos quais é projetado para armazenar um objeto do tipo definido quando foi criado.

Exemplo de código

import java.util.*;
public class LinkedListTest {

       public static void main(String args[]){

           List myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           myLinkedList.add(5);
           myLinkedList.remove(1);
           System.out.println(myLinkedList);
           myLinkedList.size(); //3
           
           //add new element at the specified position:
           myLinkedList.add(2,7);
           System.out.println(myLinkedList);
                }
       }

A saída está aqui:

Exemplo de código vetorial

Vector também é uma realização de array dinâmico e é muito semelhante a ArrayList, mas sincronizado e possui alguns métodos herdados que o framework de coleção não contém. Aqui está um exemplo simples do uso dessa classe.

import java.util.Vector;

public class VectorExample1 {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       vector.add("Alex");
       vector.add("Tanya");
       vector.add("Andrew");
       System.out.println(vector);
       vector.add("Alex");
       vector.add("Ihor");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Andrew"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Alex", 1));
       System.out.println(vector);
       vector.clear();
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

A saída é:

Exemplo de código de classe Java Stack

import java.util.Stack;

public class StackTest {
   public static void main(String[] args) {
       Stack stack = new Stack();
       System.out.println(stack.isEmpty());
       stack.add("Paul");
       stack.add("Johnny");
       stack.add("Alex");
       System.out.println(stack.isEmpty());
       stack.push("Andrew");
       System.out.println(stack);
       stack.pop();
       System.out.println(stack);
   }
}

Stack não tem apenas métodos add() e remove() , mas também push e pop, eles são clássicos para tal estrutura de dados. A pilha obedece à regra “primeiro a entrar, último a sair” - essa é uma fila tão antiquada. Portanto, a operação pop desempilha o último elemento que foi colocado na pilha. Aqui está a saída do nosso exemplo: