Classe de coleções em Java

Oi! Nas últimas lições, fizemos um grande progresso em nosso domínio do ArrayList. No entanto, até agora realizamos apenas as operações mais simples: remover, inserir e exibir. Obviamente, isso não abrange a lista completa de tarefas que os desenvolvedores devem executar ao trabalhar com ArrayList. Lembra da lição sobre arrays e a Arraysclasse? Os criadores de Java projetaram especificamente essa classe para lidar com as tarefas mais comuns que os programadores enfrentam ao trabalhar com arrays. E sobreArrayList? Certamente, existe alguma lista de tarefas comuns que precisam ser executadas com ele. Todos eles foram implementados em uma classe específica ou temos que escrever nossa própria implementação a cada vez? Claro, você não precisa escrever tudo sozinho. As operações mais comuns envolvendo coleções já foram implementadas na Collectionsclasse estática especial. Em Java, um grupo de estruturas de dados é comumente chamado de coleção . Os dados podem ser armazenados de muitas maneiras diferentes. Até agora, estudamos apenas a ArrayListclasse, onde os dados são armazenados em uma matriz. Vamos nos familiarizar com outras coleções mais tarde. Por enquanto, basta entender que a Collectionsclasse foi projetada para funcionar não apenas comArrayList, mas também com outros tipos de coleções (daí seu nome). Então, com quais tarefas a Collectionsclasse realmente ajuda ao trabalhar ArrayList? A primeira e mais óbvia é a classificação. Na lição sobre arrays, consideramos um exemplo com números. Agora vamos considerar um exemplo com strings. A Collectionsclasse implementa o sort()método para classificar o conteúdo das coleções:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

Saída: [Terra, Júpiter, Marte, Mercúrio, Netuno, Saturno, Urano, Vênus] As cordas são classificadas em ordem alfabética! Mas por que alfabeticamente? A Stringclasse realmente implementa a lógica que governa como as strings são comparadas (que acontece em ordem alfabética). Para classes que você mesmo cria, você pode implementar sua própria lógica de comparação, mas falaremos sobre isso em outras lições. A Collectionsclasse também ajuda a encontrar o elemento mínimo e máximo em um arquivo ArrayList. Isso é feito usando os métodos min()e max():

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

Saída: 7 1 Naturalmente, isso é muito mais conveniente do que escrever manualmente o código para iterar todos os elementos e encontrar o maior/menor elemento :) Outro método muito útil é reverse(). Se tivéssemos que "inverter" a lista para que os elementos ficassem na ordem oposta, como faríamos isso? Provavelmente não seria tão fácil escrever tal algoritmo sozinho :) Felizmente, o reverse()método já sabe como. Suponha que não gostemos do fato de que o sort()método classificou nossos planetas em ordem alfabética e queremos inverter sua ordem: de Z para A:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

Saída: [Vênus, Urano, Saturno, Netuno, Mercúrio, Marte, Júpiter, Terra] Temos falado muito sobre classificação, ordem dos elementos, etc. Mas e se tivéssemos o objetivo oposto? Por exemplo, suponha que estamos tentando implementar um jogo de bingo. Adicionamos 100 números ao tambor. Eles devem aparecer na tela um de cada vez. O primeiro jogador a riscar todos os números em seu bilhete ganha. Isso é fácil de implementar usando o shuffle()método:

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> bingoDrum = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           bingoDrum.add(i);// add the numbers 1 to 100 to the drum
       }

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(bingoDrum.get(i));
       }

   }
}

Saída: Sua atenção, por favor! Aqui estão os primeiros 10 números do tambor! 32 61 4 81 25 8 66 35 42 71 É muito fácil! O problema está resolvido e nossa parte do jogo está escrita :) Agora vamos imaginar uma situação diferente. Anteriormente, criamos uma solarSystemlista que continha os planetas. E parece nos servir em todos os sentidos, exceto um: você pode excluir itens dele e adicionar novos ! Este claramente não é o comportamento que esperamos: o sistema solar deve ser imutável em nosso programa. A Collectionsaula tem um método bem interessante: unmodifiableList(). Ele cria uma lista imutável da lista passada como um argumento. Você não pode adicionar ou excluir itens desta lista. Ao lidar com a lista de planetas do sistema solar, é exatamente isso que queremos!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");// Try to add a new element
   }
}

Saída: Exceção no encadeamento "main" java.lang.UnsupportedOperationException em java.util.Collections$UnmodifiableCollection.add(Collections.java:1075) em Main.main(Main.java:21) Isso é um erro: você não pode adicione qualquer coisa a solarSystem! A única coisa que você precisa prestar atenção aqui é o fato de que esse método retorna List<>(não ArrayList<>), já que esse tipo é comum para todos os tipos de listas. Outra situação bastante comum que pode facilmente acontecer é o programador adicionar elementos na ordem errada. Se isso acontecer e descobrirmos que Mercúrio e Netuno estão misturados, podemos corrigir esse erro usando o swap()método:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// The planets are in the wrong order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

Passamos para o swap()método nossa lista e os índices dos dois elementos que precisam ser trocados. Observe que o método funciona com índices, não com referências. Então, aqui a gente tinha que usar o ArrayList.indexOf()método. Saída: [Netuno, Vênus, Terra, Marte, Júpiter, Saturno, Urano, Mercúrio] [Mercúrio, Vênus, Terra, Marte, Júpiter, Saturno, Urano, Netuno] Por fim, conheceremos um método muito interessante: disjoint(). Ele verifica se duas coleções se cruzam, ou seja, se elas possuem pelo menos um elemento idêntico . Se não, ele retorna verdadeiro. Se eles fizerem, então ele retorna false

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

Como você pode ver, nossas duas listas têm elementos completamente diferentes, então o programa gera true . Esta é uma classe interessante e muito útil. Como o Arrays, ele faz muito trabalho rotineiro e tedioso para nós, permitindo que nos concentremos em outras coisas.