Coleções em Java | Coleções Java

Olá! Nas últimas lições, fizemos um grande progresso no domínio do ArrayList. Porém, durante esse tempo, realizamos apenas as operações mais simples: excluir, inserir, enviar para o console. Claro, este não é o fim da lista de problemas que os desenvolvedores enfrentam ao usar ArrayList . Lembra da palestra sobre arrays e da classe Arrays ? Foi desenvolvido pelos criadores do Java especificamente para resolver problemas comuns que os programadores encontram ao trabalhar com arrays. E quanto a ArrayList ? Certamente há alguma lista de tarefas típicas para ele também. Todos eles foram implementados em alguma classe separada ou teremos que escrever o comportamento desejado manualmente a cada vez? Claro, você não precisa escrever tudo sozinho. As operações mais comuns executadas ao usar coleções em Java já foram implementadas em uma classe estática especial Coleções.

Coleções em Java

“Coleções” é um nome genérico para diversas estruturas de dados em Java. Os dados podem ser armazenados de muitas maneiras diferentes. Até agora estudamos apenas a classe ArrayList , onde os dados são armazenados em um array. Conheceremos o restante das coleções posteriormente. Agora basta entender que a classe Collections foi projetada para funcionar não apenas com ArrayList, mas também com outros tipos de coleções em Java (daí, de fato, seu nome). Então, quais tarefas a classe Collections permite resolver ao trabalhar com ArrayList? A primeira e mais óbvia é a classificação. Na aula sobre arrays, vimos um exemplo com números e agora veremos um exemplo com strings. Para classificar o conteúdo das coleções, a classe Collections implementa o seguinte método sort():

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

   }
}

Conclusão:

[Венера, Земля, Марс, Меркурий, Нептун, Сатурн, Уран, Юпитер]

As linhas foram classificadas em ordem alfabética! Por que em ordem alfabética? A classe Stringé programada para determinar exatamente como as strings são comparadas entre si (precisamente em ordem alfabética). Para aulas que você mesmo criará, você pode implementar seu próprio mecanismo de comparação, mas falaremos sobre isso em outras palestras. Além disso, a classe Collections permite 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));

}

Conclusão:

7
1

Isso, é claro, é muito mais conveniente do que escrever código manualmente para percorrer todos os elementos e procurar o elemento maior/menor :) Outro método extremamente útil é reverse(). Se precisássemos “inverter” uma lista para que os elementos ficassem na ordem inversa, como faríamos isso? Provavelmente não seria tão fácil escrever esse algoritmo sozinho :) Felizmente, o método reverse()já sabe como fazer isso. Por exemplo, não gostamos de como o método sort()classificou nossos planetas em ordem alfabética e queremos mudar a ordem para o inverso - 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);

   }
}

Conclusão:

[Юпитер, Уран, Сатурн, Нептун, Меркурий, Марс, Земля, Венера]

A propósito, aqui falamos frequentemente sobre classificação, ordem dos elementos, etc. E se nossa tarefa for exatamente oposta? Por exemplo, estamos tentando implementar um mecanismo de loteria. Adicionamos 100 números à bobina, que devem aparecer na tela, um de cada vez. Ganha o primeiro participante que riscar todos os números do seu bilhete. É muito fácil implementar tal mecanismo usando o método shuffle():

public class Main {

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

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

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

       Collections.shuffle(lottery);//mix
       System.out.println("Attention! The first 10 numbers appear from the drum!");
       for (int i = 0; i < 10; i++) {

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

   }
}

Conclusão:

Внимание! Из барабана появляются первые 10 чисел!
32
61
4
81
25
8
66
35
42
71

É simples assim! O problema está resolvido e a nossa parte do jogo está escrita :) Agora vamos imaginar uma situação diferente. Anteriormente, criamos uma lista solarSystemcom os planetas listados nela. E parece agradar a todos nós, senão por uma coisa: você pode remover elementos dele e adicionar novos! Este não é claramente o comportamento que esperamos: o sistema solar no nosso programa deveria estar num estado inalterado. A classe Collections possui um método muito interessante - unmodifiableList(). Ele cria uma versão imutável da lista fornecida. Será impossível adicionar ou remover um elemento dele. No caso da lista de planetas do sistema solar, é exatamente disso que precisamos!

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

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1075)
	at Main.main(Main.java:21)

Erro: solarSystemagora você não pode adicionar nada! A única coisa que você precisa prestar atenção neste caso é que o tipo da variável deve ser List<>, e não ArrayList<>(este método retorna um objeto exatamente deste tipo, comum a todos os tipos de listas). Outra situação comum que pode acontecer durante o trabalho é o programador adicionar elementos na ordem errada. Se isso aconteceu e Mercúrio e Netuno mudaram de lugar inesperadamente, o método a seguir nos ajudará a corrigir esse erro swap():

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));// wrong planet order
       System.out.println(solarSystem);

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

   }
}

Passamos nossa lista para o método swap(), bem como os índices dos dois elementos que precisam ser trocados. Observação: o método funciona especificamente com índices e não com links. Portanto, aqui precisávamos de um método ArrayList.indexOf(). Conclusão:

[Нептун, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Меркурий]

[Меркурий, Венера, Земля, Марс, Юпитер, Сатурн, Уран, Нептун]

Finalmente, vamos conhecer um método muito interessante - disjoint(). Verifica se duas coleções possuem interseções, ou seja, pelo menos um elemento idêntico. Se não, retorna true, se sim, 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, os elementos em nossas duas listas são completamente diferentes, então o programa gera true. Esta é uma aula muito interessante e muito útil. Tipo Arrays, ele faz muitos trabalhos rotineiros e servis para nós, permitindo que nos concentremos em outras coisas. Leia sobre isso na documentação do Oracle , existem outros métodos lá.