TOC

Classificando matrizes em Java

Classificando matrizes em Java

1. Visão geral

Neste tutorial, discutiremos métodos comuns para classificararrays em ordem crescente e decrescente.

Veremos como usar o método de classificação de classeArrays do Java, bem como implementar nosso próprioComparator para ordenar os valores de nossos arrays.

2. Definições de Objeto

Antes de começar, vamos definir rapidamente algumas matrizes que classificaremos ao longo deste tutorial. Primeiro, vamos criar uma matriz deintse uma matriz de strings: 

int[] numbers = new int[] { -8, 7, 5, 9, 10, -2, 3 };
String[] strings = new String[] { "learning", "java", "with", "example" };

E vamos também criar uma matriz deEmployee objetos onde cada funcionário tem umid e umname attribute: 

Employee john = new Employee(6, "John");
Employee mary = new Employee(3, "Mary");
Employee david = new Employee(4, "David");
Employee[] employees = new Employee[] { john, mary, david };

3. Classificando em ordem crescente

O métodoutil.Arrays.sort de Java nos fornece uma maneira rápida e simples de classificar uma matriz de primitivas ou objetos que implementam a interfaceComparable em ordem crescente.

Ao classificar primitivas, o métodoArrays.sort usa uma implementação Dual-Pivot deQuicksort. No entanto, ao classificar objetos, uma implementação iterativa deMergeSort é usada.

3.1. Primitivas

Para classificar uma matriz primitiva em ordem crescente, passamos nossa matriz para o métodosort : 

Arrays.sort(numbers);
assertArrayEquals(new int[] { -8, -2, 3, 5, 7, 9, 10 }, numbers);

3.2. Objetos que implementam comparável

Para objetos que implementam a sinterfaceComparable , como com nosso array primitivo, também podemos simplesmente passar nosso array para o métodosort: 

Arrays.sort(strings);
assertArrayEquals(new String[] { "example", "java", "learning", "with" }, strings);

3.3. Objetos que não implementam comparáveis

Classificar objetos que não implementamComparable Interface, como nosso array deEmployees, requer que especificemos nosso próprio comparador.

Podemos fazer isso facilmente em Java 8 especificando a propriedade que gostaríamos de comparar nossosEmployee objetos em nossosComparator: 

Arrays.sort(employees, Comparator.comparing(Employee::getName));
assertArrayEquals(new Employee[] { david, john, mary }, employees);

Nesse caso, especificamos que gostaríamos de ordenar nossos funcionários porname attributes.

Também podemos classificar nossos objetos em mais de um atributo, encadeando nossas comparações usandoComparator’s thenComparing method: 

Arrays.sort(employees, Comparator.comparing(Employee::getName).thenComparing(Employee::getId));

4. Classificação em ordem decrescente

4.1. Primitivas

Classificar uma matriz primitiva em ordem decrescente não é tão simples quanto classificá-la em ordem crescente porque Java não suporta o uso de tipos primitivosComparators filho. Para superar esse déficit, temos algumas opções.

Primeiro, poderíamossort our array in ascending order and then do an in-place reversal do array.

Em segundo lugar, poderia converter nosso array em uma lista,use Guava’s Lists.reverse() methode converter nossa lista de volta em um array.

Finalmente, poderíamos transformar nosso array em uma areiaStream e então mapeá-lo de volta para um arrayint. Tem uma boa vantagem de sera one-liner and just using core Java: 

numbers = IntStream.of(numbers).boxed().sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();
assertArrayEquals(new int[] { 10, 9, 7, 5, 3, -2, -8 }, numbers);

A razão disso funcionar é queboxed transforma cadaint em umInteger, quedoes implementaComparator.

4.2. Objetos que implementam comparável

Classificar uma matriz de objeto que implementa a sinterfaceComparable em ordem decrescente é bastante simples. Tudo o que precisamos fazer é passarComparator  como o segundo parâmetro de nosso métodosort.

No Java 8, podemos usarComparator.reverseOrder() to para indicar que gostaríamos que nosso array fosse classificado em ordem decrescente: 

Arrays.sort(strings, Comparator.reverseOrder());
assertArrayEquals(new String[] { "with", "learning", "java", "example" }, strings);

4.3. Objetos que não implementam comparáveis

Da mesma forma que classificar objetos que implementam comparáveis, podemos inverter a ordem de nossoComparator  personalizado adicionandoreversed() ao final de nossa definição de comparação: 

Arrays.sort(employees, Comparator.comparing(Employee::getName).reversed());
assertArrayEquals(new Employee[] { mary, john, david }, employees);

5. Conclusão

Neste artigo, discutimos como classificar matrizes de primitivas e objetos em ordem crescente e decrescente usando o métodoArrays.sort.

Como de costume, o código-fonte deste artigo pode ser encontradoover on Github.

Related