0Pricing
Java Academy · Aula

Ordenação de Matrizes e Coleções na Prática

Aplique ordenação a listas de produtos, classificações e agendas de eventos usando exemplos do mundo real.

Ordenação de Matrizes e Coleções na Prática é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Ordenação na prática

Esta lição aplica técnicas de ordenação a cenários realistas: catálogos de produtos, classificações, agendamento de eventos e ranqueamento de resultados de busca.

Arrays.sort para vetores primitivos

Arrays.sort() para vetores primitivos usa quicksort de pivô duplo — extremamente rápido, com O(n log n) em média.

int[] scores = {45, 90, 78, 62, 88, 33};
Arrays.sort(scores);
System.out.println(Arrays.toString(scores)); // [33, 45, 62, 78, 88, 90]

// Sort a range only
int[] data = {9, 3, 7, 1, 5};
Arrays.sort(data, 1, 4); // sort indices 1-3 only
System.out.println(Arrays.toString(data)); // [9, 1, 3, 7, 5]

Arrays.sort para vetores de objetos

Para vetores de objetos, Arrays.sort() usa TimSort (estável). Você pode fornecer um Comparator para definir uma ordenação personalizada.

String[] names = {"Charlie", "Alice", "Bob", "Diana"};
Arrays.sort(names);
System.out.println(Arrays.toString(names)); // [Alice, Bob, Charlie, Diana]

// Custom order: by length, then alphabetically
Arrays.sort(names, Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));
System.out.println(Arrays.toString(names)); // [Bob, Alice, Diana, Charlie]

Collections.sort e List.sort

Ambos ordenam a lista no próprio local. List.sort() é a forma moderna preferida.

List<Integer> nums = new ArrayList<>(List.of(5, 2, 8, 1, 9, 3));

// Old way
Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

// Modern way (same result)
nums.sort(Comparator.naturalOrder());
nums.sort(null); // null means natural order

// Descending
nums.sort(Comparator.reverseOrder());
System.out.println(nums); // [9, 8, 5, 3, 2, 1]

Stream.sorted() para um estilo funcional

Use stream().sorted() ao criar um fluxo de processamento — isso produz um novo fluxo ordenado sem modificar a fonte.

List<String> cities = List.of("Tokyo", "London", "New York", "Paris", "Sydney");

// Sorted stream — source list unchanged
List<String> sorted = cities.stream()
    .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
    .collect(Collectors.toList());

System.out.println(sorted);
// [Paris, Tokyo, London, Sydney, New York]

Ordenando um mapa por valor

Uma pergunta clássica de entrevistas: ordenar um mapa por seus valores usando stream e um comparador.

import java.util.*;
import java.util.stream.*;

Map<String, Integer> scores = Map.of(
    "Alice", 95, "Bob", 87, "Charlie", 92, "Diana", 87
);

Map<String, Integer> sorted = scores.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue(Comparator.reverseOrder())
        .thenComparing(Map.Entry.comparingByKey()))
    .collect(Collectors.toLinkedHashMap(
        Map.Entry::getKey, Map.Entry::getValue,
        (v1, v2) -> v1, LinkedHashMap::new));

sorted.forEach((k, v) -> System.out.println(k + ": " + v));
// Alice: 95 / Charlie: 92 / Bob: 87 / Diana: 87

Ordenando com Collator para uma localidade

Para ordenar strings considerando o idioma, use java.text.Collator em vez de String.compareTo — ele trata acentos, maiúsculas e minúsculas e a ordenação específica da localidade.

import java.text.*;
import java.util.*;

List<String> names = new ArrayList<>(List.of("éclair", "apple", "Über", "banana"));

Collator collator = Collator.getInstance(Locale.GERMAN);
names.sort(collator);
System.out.println(names); // locale-aware sort

Ordenando objetos com vários critérios

Ordenação de produtos de comércio eletrônico: primeiro os disponíveis em estoque, depois por preço promocional, em seguida por avaliação e, por fim, por nome.

record Product(String name, double price, double salePrice, double rating, boolean inStock) {}

Comparator<Product> bestFirst = Comparator
    .comparing(Product::inStock).reversed()           // in-stock first
    .thenComparingDouble(Product::salePrice)          // cheapest sale price
    .thenComparingDouble(Product::rating).reversed()  // highest rated
    .thenComparing(Product::name);                    // alphabetical tiebreak

Ordenando eventos por data e hora

Ordene cronologicamente uma agenda de eventos usando tipos de java.time que implementam comparação.

import java.time.*;
import java.util.*;

record Event(String title, LocalDate date, LocalTime time) {}

List<Event> schedule = new ArrayList<>(List.of(
    new Event("Workshop",  LocalDate.of(2024,7,15), LocalTime.of(9, 0)),
    new Event("Keynote",   LocalDate.of(2024,7,14), LocalTime.of(10, 30)),
    new Event("Lunch Talk",LocalDate.of(2024,7,15), LocalTime.of(12, 0)),
    new Event("Hackathon", LocalDate.of(2024,7,14), LocalTime.of(9, 0))
));

schedule.sort(Comparator.comparing(Event::date).thenComparing(Event::time));
schedule.forEach(e -> System.out.println(e.date() + " " + e.time() + " " + e.title()));

Elementos do tipo top-N com ordenação

Encontre os elementos do tipo top-N com eficiência: ordene em ordem decrescente e obtenha os primeiros N, ou use uma PriorityQueue para grandes conjuntos de dados.

List<Integer> values = List.of(42, 17, 88, 5, 73, 56, 91, 33);

// Simple approach: sort descending, take first 3
List<Integer> top3 = values.stream()
    .sorted(Comparator.reverseOrder())
    .limit(3)
    .collect(Collectors.toList());
System.out.println(top3); // [91, 88, 73]

// For very large datasets: PriorityQueue min-heap approach is O(n log k)
import java.util.PriorityQueue;
PriorityQueue<Integer> heap = new PriorityQueue<>(3);
for (int v : values) {
    heap.offer(v);
    if (heap.size() > 3) heap.poll();
}
System.out.println(new TreeSet<>(heap).descendingSet()); // [73, 88, 91]

Eliminação de duplicatas com ordenação

Após a ordenação, as duplicatas ficam adjacentes — é possível detectá-las em O(n).

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5};
Arrays.sort(arr); // sort first

// Remove duplicates in O(n) after sorting
int[] unique = Arrays.stream(arr).distinct().toArray();
System.out.println(Arrays.toString(unique)); // [1, 2, 3, 4, 5, 6, 9]

Desempenho: escolhendo o método de ordenação

Escolha a abordagem de ordenação correta:

  • Vetores primitivos: Arrays.sort() — mais rápido, com quicksort no próprio local
  • Vetores ou listas de objetos com Comparable: Collections.sort() ou List.sort(null)
  • Várias ordenações: cadeias de comparadores com thenComparing
  • Top-N de um fluxo grande: PriorityQueue ou Stream.sorted().limit(N)

Verificação rápida

Qual algoritmo de ordenação o Java usa para vetores de objetos em Arrays.sort()?

Recapitulação: ordenando vetores e coleções na prática

Principais conclusões:

  • Arrays.sort() usa quicksort de pivô duplo para tipos primitivos e TimSort (estável) para objetos
  • List.sort() com um comparador e Collections.sort() são ambos TimSort estáveis
  • stream().sorted() produz um novo fluxo ordenado sem modificar a fonte
  • Ordene um mapa por valor com: entrySet().stream().sorted(Map.Entry.comparingByValue())
  • Use Collator para ordenar strings considerando a localidade
  • Para obter o top-N de grandes volumes de dados: uma PriorityQueue com capacidade k é mais eficiente do que uma ordenação completa

Perguntas Frequentes

A aula “Ordenação de Matrizes e Coleções na Prática” é grátis?

Sim — o texto completo de “Ordenação de Matrizes e Coleções na Prática” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Ordenação de Matrizes e Coleções na Prática”?

Aplique ordenação a listas de produtos, classificações e agendas de eventos usando exemplos do mundo real. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Ordenação de Matrizes e Coleções na Prática”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. A Interface Comparable
  2. Ordenação com Comparator e Lambdas
  3. Ordenação por Várias Chaves com thenComparing
  4. Ordenação de Matrizes e Coleções na Prática
← Voltar para Java Academy