Algoritmos Java (Algoritmos)

Neste tutorial, vamos aprender com exemplos diferentes algoritmos oferecidos pelo framework de coleções Java.

A framework de coleções Java oferece várias algoritmos, que podem ser usados para manipular elementos armazenados em estruturas de dados.

Os algoritmos no Java são métodos estáticos, usados para executar várias operações em conjuntos.

Devido ao fato de que os algoritmos podem ser usados em vários conjuntos, também são chamados dealgoritmos gerais.

Vamos ver as implementações dos diferentes métodos disponíveis no framework de conjunto.

1.usar sort() para ordenar

métodos do framework de conjunto sort() são usados para ordenar elementos. Por exemplo,

import java.util.ArrayList;
import java.util.Collections;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//criar uma lista de array
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　//adicionar elementos
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("ArrayList não ordenado: ",　+　numbers);
　　　　　　　　//　usar o método sort()
　　　　　　　　Collections.sort(numbers);
　　　　　　　　System.out.println("ArrayList ordenado: ",　+　numbers);
　　　　}
}

Resultados de saída

ArrayList não ordenado: [4,　2,　3]
ArrayList ordenado: [2,　3,　4]

Aqui, a ordenação é feita em ordem natural (crescente). Mas, podemos usar o Comparator para personalizar a ordem de ordenação do método sort().

Para obter mais informações, acesseordenação Java.

2.usar shuffle para baralhar

O método shuffle() do framework Java Collections é usado para desordena qualquer ordem que apareça na estrutura de dados. Seu efeito é o oposto da ordenação. Por exemplo

import java.util.ArrayList;
import java.util.Collections;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//criar uma lista de array
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　//adicionar elementos
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("ArrayList ordenado: ",　+　numbers);
　　　　　　　　//usar o método shuffle()
　　　　　　　　Collections.shuffle(numbers);
　　　　　　　　System.out.println("ArrayList usando shuffle: ",　+　numbers);
　　　　}
}

Resultados de saída

ArrayList ordenado: [1,　2,　3]
ArrayList usando shuffle: [2,　1,　3]

ao executar o programa, o método shuffle() retornará uma saída aleatória.

algoritmos de baralhar são usados principalmente em jogos que precisam de saídas aleatórias.

3.manipulação de dados comuns

No Java, a estrutura de conjunto oferece diferentes métodos para manipulação de dados.

• reverse() - inverter a ordem dos elementos

• fill() - substituir cada elemento do conjunto com um valor especificado

• copy() - criar uma cópia dos elementos de origem para destino

• swap() - trocar a posição de dois elementos no conjunto

• addAll() - adicionar todos os elementos do conjunto a outro conjunto

Por exemplo,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　System.out.println("ArrayList1: \　+　numbers);
　　　　　　　　//　usar reverse()
　　　　　　　　Collections.reverse(numbers);
　　　　　　　　System.out.println("inverter ArrayList1: \　+　numbers);
　　　　　　　　//　usar swap()
　　　　　　　　Collections.swap(numbers, 0,　1);
　　　　　　　　System.out.println("ArrayList1　usar swap(): ",　+　numbers);
　　　　　　　　ArrayList<Integer> newNumbers = new ArrayList<>();
　　　　　　　　//　usar addAll
　　　　　　　　newNumbers.addAll(numbers);
　　　　　　　　System.out.println("ArrayList2　usar addAll(): \　+　newNumbers);
　　　　　　　　//　usar fill()
　　　　　　　　Collections.fill(numbers, 0);
　　　　　　　　System.out.println("ArrayList1　usar fill(): \　+　numbers);
　　　　　　　　//　usar copy()
　　　　　　　　Collections.copy(newNumbers, numbers);
　　　　　　　　System.out.println("ArrayList2　usar copy(): \　+　newNumbers);
　　　　}
}

Resultados de saída

ArrayList1: [1,　2]
inverter ArrayList1: [2,　1]
ArrayList1　usar swap(): [1,　2]
ArrayList2　usar addAll(): [1,　2]
ArrayList1　usar fill(): [0, 0]
ArrayList2　usar copy(): [0, 0]

Atenção：Quando executar o método copy(), o tamanho de duas listas deve ser o mesmo.

4.usar binarySearch() para buscar

O método binarySearch() da framework de coleções Java busca o elemento especificado. Ele retorna a posição do elemento no conjunto especificado. Por exemplo,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　//　usar binarySearch()
　　　　　　　　int pos = Collections.binarySearch(numbers,　3);
　　　　　　　　System.out.println("3a posição é \　+　pos);
　　　　}
}

Resultados de saída

3a posição é　2

Atenção：Antes de executar o método binarySearch(), o conjunto deve ser ordenado.

Para obter mais informações, acesseJava Binary Search.

5.combinação

• frequency() - retorna a contagem de ocorrências do elemento no conjunto

• disjoint() - verificar se dois conjuntos contêm alguns elementos comuns

Por exemplo,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(2);
　　　　　　　　System.out.println("ArrayList1: \　+　numbers);
　　　　　　　　int count = Collections.frequency(numbers,　2);
　　　　　　　　System.out.println("Contagem de　2: \　+　count);
　　　　　　　　ArrayList<Integer> newNumbers = new ArrayList<>();
　　　　　　　　newNumbers.add(5);
　　　　　　　　newNumbers.add(6);
　　　　　　　　System.out.println("ArrayList2: \　+　newNumbers);
　　　　　　　　boolean value = Collections.disjoint(numbers, newNumbers);
　　　　　　　　System.out.println("Dois conjuntos não se intersectam? ",　+　value);
　　　　}
}

Resultados de saída

ArrayList1: [1,　2,　3,　2]
Contagem de　2:　2
ArrayList2: [5,　6]
dois conjuntos não se intersectam? true

6procurar o maior e o menor elemento

A framework de coleções Java, os métodos min() e max() são usados para encontrar o menor e o maior elemento, respectivamente. Por exemplo,

import java.util.Collections;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Criar um ArrayList
　　　　　　　　ArrayList<Integer> numbers = new ArrayList<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　//　Usar min()
　　　　　　　　int min = Collections.min(numbers);
　　　　　　　　System.out.println("Elemento mínimo: ");　+　min);
　　　　　　　　//　Usar max()
　　　　　　　　int max = Collections.max(numbers);
　　　　　　　　System.out.println("Elemento máximo: ");　+　max);
　　　　}
}

Resultados de saída

Elemento mínimo:　1
Elemento máximo:　3