Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Java

Dominando Java TreeSet: Operações, Métodos e Exemplos Práticos

Java TreeSet

Neste tutorial, aprenderemos sobre a classe TreeSet do Java e suas diversas operações e métodos com a ajuda de exemplos.

A classe TreeSet do framework de coleções Java fornece a funcionalidade de uma estrutura de dados de árvore.

Ela estende a interface NavigableSet.


Criando um TreeSet

Para criar um tree set, primeiro devemos importar o pacote java.util.TreeSet.

Após importar o pacote, veja como podemos criar um TreeSet em Java.

TreeSet<Integer> numeros = new TreeSet<>();

Aqui, criamos um TreeSet sem argumentos. Nesse caso, os elementos no TreeSet são ordenados naturalmente (ordem crescente).

No entanto, podemos personalizar a ordenação dos elementos usando a interface Comparator. Aprenderemos sobre isso mais adiante neste tutorial.


Métodos do TreeSet

A classe TreeSet fornece vários métodos que nos permitem realizar diversas operações no conjunto.


Inserir Elementos no TreeSet

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numerosPares = new TreeSet<>();
        // Usando o método add()
        numerosPares.add(2);
        numerosPares.add(4);
        numerosPares.add(6);
        System.out.println("TreeSet: " + numerosPares);
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(1);
        // Usando o método addAll()
        numeros.addAll(numerosPares);
        System.out.println("Novo TreeSet: " + numeros);
    }
}

Saída

TreeSet: [2, 4, 6]
Novo TreeSet: [1, 2, 4, 6]

Acessar Elementos do TreeSet

Para acessar os elementos de um tree set, podemos usar o método iterator(). Para usar este método, devemos importar o pacote java.util.Iterator. Por exemplo,

import java.util.TreeSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Chamando o método iterator()
        Iterator<Integer> iterador = numeros.iterator();
        System.out.print("TreeSet usando Iterator: ");
        // Acessando elementos
        while(iterador.hasNext()) {
            System.out.print(iterador.next());
            System.out.print(", ");
        }
    }
}

Saída

TreeSet: [2, 5, 6]
TreeSet usando Iterator: 2, 5, 6, 

Remover Elementos

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando o método remove()
        boolean valor1 = numeros.remove(5);
        System.out.println("O 5 foi removido? " + valor1);
        // Usando o método removeAll()
        boolean valor2 = numeros.removeAll(numeros);
        System.out.println("Todos os elementos foram removidos? " + valor2);
    }
}

Saída

TreeSet: [2, 5, 6]
O 5 foi removido? true
Todos os elementos foram removidos? true

Como a classe TreeSet implementa NavigableSet, ela fornece vários métodos para navegar sobre os elementos do tree set.

1. Métodos first() e last()

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando o método first()
        int primeiro = numeros.first();
        System.out.println("Primeiro Número: " + primeiro);
        // Usando o método last()
        int ultimo = numeros.last();
        System.out.println("Último Número: " + ultimo);
    }
}

Saída

TreeSet: [2, 5, 6]
Primeiro Número: 2
Último Número: 6

2. Métodos ceiling(), floor(), higher() e lower()

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(4);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando higher()
        System.out.println("Usando higher: " + numeros.higher(4));
        // Usando lower()
        System.out.println("Usando lower: " + numeros.lower(4));
        // Usando ceiling()
        System.out.println("Usando ceiling: " + numeros.ceiling(4));
        // Usando floor()
        System.out.println("Usando floor: " + numeros.floor(3));
    }
}

Saída

TreeSet: [2, 4, 5, 6]
Usando higher: 5
Usando lower: 2
Usando ceiling: 4
Usando floor: 2

3. Métodos pollFirst() e pollLast()

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(4);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando pollFirst()
        System.out.println("Primeiro Elemento Removido: " + numeros.pollFirst());
        // Usando pollLast()
        System.out.println("Último Elemento Removido: " + numeros.pollLast());
        System.out.println("Novo TreeSet: " + numeros);
    }
}

Saída

TreeSet: [2, 4, 5, 6]
Primeiro Elemento Removido: 2
Último Elemento Removido: 6
Novo TreeSet: [4, 5]

4. Métodos headSet(), tailSet() e subSet()


headSet(elemento, valorBooleano)

O método headSet() retorna todos os elementos de um tree set antes do elemento especificado (passado como argumento).

O parâmetro valorBooleano é opcional. Seu valor padrão é false.

Se true for passado como valorBooleano, o método retorna todos os elementos antes do elemento especificado, incluindo o próprio elemento.

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(4);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando headSet() com valor booleano padrão
        System.out.println("Usando headSet sem valor booleano: " + numeros.headSet(5));
        // Usando headSet() com valor booleano especificado
        System.out.println("Usando headSet com valor booleano: " + numeros.headSet(5, true));
    }
}

Saída

TreeSet: [2, 4, 5, 6]
Usando headSet sem valor booleano: [2, 4]
Usando headSet com valor booleano: [2, 4, 5]

tailSet(elemento, valorBooleano)

O método tailSet() retorna todos os elementos de um tree set após o elemento especificado (passado como parâmetro), incluindo o elemento especificado.

O parâmetro valorBooleano é opcional. Seu valor padrão é true.

Se false for passado como valorBooleano, o método retorna todos os elementos após o elemento especificado sem incluir o elemento especificado.

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(4);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando tailSet() com valor booleano padrão
        System.out.println("Usando tailSet sem valor booleano: " + numeros.tailSet(4));
        // Usando tailSet() com valor booleano especificado
        System.out.println("Usando tailSet com valor booleano: " + numeros.tailSet(4, false));
    }
}

Saída

TreeSet: [2, 4, 5, 6]
Usando tailSet sem valor booleano: [4, 5, 6]
Usando tailSet com valor booleano: [5, 6]

subSet(e1, bv1, e2, bv2)

O método subSet() retorna todos os elementos entre e1 e e2, incluindo e1.

Os parâmetros bv1 e bv2 são opcionais. O valor padrão de bv1 é true, e o de bv2 é false.

Se false for passado como bv1, o método retorna todos os elementos entre e1 e e2 sem incluir e1.

Se true for passado como bv2, o método retorna todos os elementos entre e1 e e2, incluindo e1.

Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(2);
        numeros.add(5);
        numeros.add(4);
        numeros.add(6);
        System.out.println("TreeSet: " + numeros);
        // Usando subSet() com valor booleano padrão
        System.out.println("Usando subSet sem valor booleano: " + numeros.subSet(4, 6));
        // Usando subSet() com valor booleano especificado
        System.out.println("Usando subSet com valor booleano: " + numeros.subSet(4, false, 6, true));
    }
}

Saída

TreeSet: [2, 4, 5, 6]
Usando subSet sem valor booleano: [4, 5]
Usando subSet com valor booleano: [5, 6]

Operações de Conjunto

Os métodos da classe TreeSet também podem ser usados para realizar várias operações de conjunto.


União de Conjuntos

Para realizar a união entre dois conjuntos, usamos o método addAll(). Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numerosPares = new TreeSet<>();
        numerosPares.add(2);
        numerosPares.add(4);
        System.out.println("TreeSet1: " + numerosPares);
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(1);
        numeros.add(2);
        numeros.add(3);
        System.out.println("TreeSet2: " + numeros);
        // União de dois conjuntos
        numeros.addAll(numerosPares);
        System.out.println("União é: " + numeros);
    }
}

Saída

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
União é: [1, 2, 3, 4]

Interseção de Conjuntos

Para realizar a interseção entre dois conjuntos, usamos o método retainAll(). Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numerosPares = new TreeSet<>();
        numerosPares.add(2);
        numerosPares.add(4);
        System.out.println("TreeSet1: " + numerosPares);
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(1);
        numeros.add(2);
        numeros.add(3);
        System.out.println("TreeSet2: " + numeros);
        // Interseção de dois conjuntos
        numeros.retainAll(numerosPares);
        System.out.println("Interseção é: " + numeros);
    }
}

Saída

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Interseção é: [2]

Diferença de Conjuntos

Para calcular a diferença entre dois conjuntos, podemos usar o método removeAll(). Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numerosPares = new TreeSet<>();
        numerosPares.add(2);
        numerosPares.add(4);
        System.out.println("TreeSet1: " + numerosPares);
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(1);
        numeros.add(2);
        numeros.add(3);
        numeros.add(4);
        System.out.println("TreeSet2: " + numeros);
        // Diferença entre dois conjuntos
        numeros.removeAll(numerosPares);
        System.out.println("Diferença é: " + numeros);
    }
}

Saída

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
Diferença é: [1, 3]

Subconjunto de um Conjunto

Para verificar se um conjunto é subconjunto de outro, usamos o método containsAll(). Por exemplo,

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numeros = new TreeSet<>();
        numeros.add(1);
        numeros.add(2);
        numeros.add(3);
        numeros.add(4);
        System.out.println("TreeSet1: " + numeros);
        TreeSet<Integer> numerosPrimos = new TreeSet<>();
        numerosPrimos.add(2);
        numerosPrimos.add(3);
        System.out.println("TreeSet2: " + numerosPrimos);
        // Verifica se numerosPrimos é subconjunto de numeros
        boolean resultado = numeros.containsAll(numerosPrimos);
        System.out.println("TreeSet2 é subconjunto de TreeSet1? " + resultado);
    }
}

Saída

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
TreeSet2 é subconjunto de TreeSet1? true

Outros Métodos do TreeSet

MétodoDescrição
clone()Cria uma cópia do TreeSet
contains()Busca o elemento especificado no TreeSet e retorna um resultado booleano
isEmpty()Verifica se o TreeSet está vazio
size()Retorna o tamanho do TreeSet
clear()Remove todos os elementos do TreeSet

Para saber mais, visite Java TreeSet (documentação oficial do Java).


TreeSet vs. HashSet

Tanto TreeSet quanto HashSet implementam a interface Set. No entanto, existem algumas diferenças entre eles.


TreeSet Comparator

Em todos os exemplos acima, os elementos do tree set são ordenados naturalmente. No entanto, também podemos personalizar a ordenação dos elementos.

Para isso, precisamos criar nossa própria classe comparador baseada na qual os elementos em um tree set são ordenados. Por exemplo,

import java.util.TreeSet;
import java.util.Comparator;

class Main {
    public static void main(String[] args) {
        // Criando um tree set com comparador personalizado
        TreeSet<String> animais = new TreeSet<>(new ComparadorPersonalizado());
        animais.add("Cachorro");
        animais.add("Zebra");
        animais.add("Gato");
        animais.add("Cavalo");
        System.out.println("TreeSet: " + animais);
    }
    // Criando uma classe comparador
    public static class ComparadorPersonalizado implements Comparator<String> {
        @Override
        public int compare(String animal1, String animal2) {
            int valor = animal1.compareTo(animal2);
            // elementos são ordenados em ordem reversa
            if (valor > 0) {
                return -1;
            } else if (valor < 0) {
                return 1;
            } else {
                return 0;
            }
        }
    }
}

Saída

TreeSet: [Zebra, Cavalo, Cachorro, Gato]

No exemplo acima, criamos um tree set passando a classe ComparadorPersonalizado como argumento.

A classe ComparadorPersonalizado implementa a interface Comparator.

Então sobrescrevemos o método compare(). O método agora ordenará os elementos em ordem reversa.

Para saber mais, visite Java Comparator (documentação oficial do Java).

Java

  1. Dominando Operadores Java: Tipos, Sintaxe e Exemplos Práticos
  2. Comentários em Java: Tipos, Uso e Boas Práticas
  3. Dominando o Loop for Aprimorado em Java: Sintaxe, Exemplos e Boas Práticas
  4. Dominando Strings em Java: Criação, Métodos e Boas Práticas
  5. Dominando Interfaces em Java: Conceitos, Implementação e Boas Práticas
  6. Dominando Classes Internas Anônimas em Java: Definição, Sintaxe e Exemplos Práticos
  7. Dominando Try-With-Resources em Java: Gerenciamento Automático de Recursos Explicado
  8. Anotações em Java Explicadas: Tipos, Posicionamento e Exemplos Práticos
  9. Asserções em Java: Guia Prático para Detectar Bugs e Garantir Confiabilidade do Código
  10. Dominando Algoritmos de Coleção Java: Ordenação, Embaralhamento e Mais