Algoritmos Java
Algoritmos Java
Neste tutorial, aprenderemos sobre diferentes algoritmos fornecidos pelo framework de coleções Java com a ajuda de exemplos.
A estrutura de coleções Java fornece vários algoritmos que podem ser usados para manipular elementos armazenados em estruturas de dados.
Algoritmos em Java são métodos estáticos que podem ser usados para realizar várias operações em coleções.
Como os algoritmos podem ser usados em várias coleções, eles também são conhecidos como algoritmos genéricos .
Vamos ver a implementação de diferentes métodos disponíveis no framework de coleções.
1. Ordenando usando sort()
O
sort() O método fornecido pela estrutura de coleções é usado para classificar elementos. Por exemplo,
import java.util.ArrayList;
import java.util.Collections;
class Main {
public static void main(String[] args) {
// Creating an array list
ArrayList<Integer> numbers = new ArrayList<>();
// Add elements
numbers.add(4);
numbers.add(2);
numbers.add(3);
System.out.println("Unsorted ArrayList: " + numbers);
// Using the sort() method
Collections.sort(numbers);
System.out.println("Sorted ArrayList: " + numbers);
}
}
Saída
Unsorted ArrayList: [4, 2, 3] Sorted ArrayList: [2, 3, 4]
Aqui a ordenação ocorre em ordem natural (ordem crescente). No entanto, podemos personalizar a ordem de classificação do
sort() método usando a interface do comparador . Para saber mais, visite Classificação Java.
2. Embaralhando usando shuffle()
O
shuffle() O método do framework de coleções Java é usado para destruir qualquer tipo de ordem presente na estrutura de dados. Ele faz exatamente o oposto da classificação. Por exemplo,
import java.util.ArrayList;
import java.util.Collections;
class Main {
public static void main(String[] args) {
// Creating an array list
ArrayList<Integer> numbers = new ArrayList<>();
// Add elements
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("Sorted ArrayList: " + numbers);
// Using the shuffle() method
Collections.shuffle(numbers);
System.out.println("ArrayList using shuffle: " + numbers);
}
}
Saída
Sorted ArrayList: [1, 2, 3] ArrayList using shuffle: [2, 1, 3]
Quando executamos o programa, o
shuffle() O método retornará uma saída aleatória. O algoritmo de embaralhamento é usado principalmente em jogos em que queremos saída aleatória.
3. Manipulação de dados de rotina
Em Java, a estrutura de coleções fornece diferentes métodos que podem ser usados para manipular dados.
reverse()- inverte a ordem dos elementosfill()- substituir cada elemento em uma coleção pelo valor especificadocopy()- cria uma cópia de elementos da origem especificada para o destinoswap()- troca a posição de dois elementos em uma coleçãoaddAll()- adiciona todos os elementos de uma coleção a outra coleção
Por exemplo,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
System.out.println("ArrayList1: " + numbers);
// Using reverse()
Collections.reverse(numbers);
System.out.println("Reversed ArrayList1: " + numbers);
// Using swap()
Collections.swap(numbers, 0, 1);
System.out.println("ArrayList1 using swap(): " + numbers);
ArrayList<Integer> newNumbers = new ArrayList<>();
// Using addAll
newNumbers.addAll(numbers);
System.out.println("ArrayList2 using addAll(): " + newNumbers);
// Using fill()
Collections.fill(numbers, 0);
System.out.println("ArrayList1 using fill(): " + numbers);
// Using copy()
Collections.copy(newNumbers, numbers);
System.out.println("ArrayList2 using copy(): " + newNumbers);
}
}
Saída
ArrayList1: [1, 2] Reversed ArrayList1: [2, 1] ArrayList1 Using swap(): [1, 2] ArrayList2 using addALl(): [1, 2] ArrayList1 using fill(): [0, 0] ArrayList2 using copy(): [0, 0]
Observação :Durante a execução do
copy() ambas as listas devem ter o mesmo tamanho. 4. Pesquisando usando binarySearch()
O
binarySearch() O método da estrutura de coleções Java procura o elemento especificado. Ele retorna a posição do elemento nas coleções especificadas. Por exemplo,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
// Using binarySearch()
int pos = Collections.binarySearch(numbers, 3);
System.out.println("The position of 3 is " + pos);
}
}
Saída
The position of 3 is 2.
Observação :A coleção deve ser classificada antes de executar o
binarySearch() método. Para saber mais, visite Java Binary Search.
5. Composição
frequency()- retorna a contagem do número de vezes que um elemento está presente na coleçãodisjoint()- verifica se duas coleções contêm algum elemento comum
Por exemplo,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an 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("Count of 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("Two lists are disjoint: " + value);
}
}
Saída
ArrayList1: [1, 2, 3, 2] Count of 2: 2 ArrayList2: [5, 6] Two lists are disjoint: true
6. Encontrando valores extremos
O
min() e max() métodos da estrutura de coleções Java são usados para encontrar os elementos mínimo e máximo, respectivamente. Por exemplo,
import java.util.Collections;
import java.util.ArrayList;
class Main {
public static void main(String[] args) {
// Creating an ArrayList
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
// Using min()
int min = Collections.min(numbers);
System.out.println("Minimum Element: " + min);
// Using max()
int max = Collections.max(numbers);
System.out.println("Maximum Element: " + max);
}
}
Saída
Minimum Element: 1 Maximum Element: 3
Java