Algoritmos de Java
Algoritmos de Java
En este tutorial, aprenderemos sobre diferentes algoritmos proporcionados por el marco de colecciones de Java con la ayuda de ejemplos.
El marco de colecciones de Java proporciona varios algoritmos que se pueden usar para manipular elementos almacenados en estructuras de datos.
Los algoritmos en Java son métodos estáticos que se pueden usar para realizar varias operaciones en las colecciones.
Dado que los algoritmos se pueden usar en varias colecciones, también se conocen como algoritmos genéricos. .
Veamos la implementación de diferentes métodos disponibles en el marco de las colecciones.
1. Ordenar usando sort()
El sort() El método proporcionado por el marco de las colecciones se utiliza para ordenar los elementos. Por ejemplo,
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);
}
}
Salida
Unsorted ArrayList: [4, 2, 3] Sorted ArrayList: [2, 3, 4]
Aquí la clasificación ocurre en orden natural (orden ascendente). Sin embargo, podemos personalizar el orden de clasificación de los sort() método utilizando la interfaz Comparator .
Para obtener más información, visite Clasificación de Java.
2. Barajar usando shuffle()
El shuffle() El método del marco de colecciones de Java se utiliza para destruir cualquier tipo de orden presente en la estructura de datos. Hace justo lo contrario de la clasificación. Por ejemplo,
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);
}
}
Salida
Sorted ArrayList: [1, 2, 3] ArrayList using shuffle: [2, 1, 3]
Cuando ejecutamos el programa, el shuffle() método devolverá una salida aleatoria.
El algoritmo de barajado se usa principalmente en juegos en los que queremos resultados aleatorios.
3. Manipulación de datos de rutina
En Java, el marco de las colecciones proporciona diferentes métodos que se pueden usar para manipular datos.
reverse()- invierte el orden de los elementosfill()- reemplaza cada elemento en una colección con el valor especificadocopy()- crea una copia de los elementos desde el origen especificado hasta el destinoswap()- intercambia la posición de dos elementos en una colecciónaddAll()- agrega todos los elementos de una colección a otra colección
Por ejemplo,
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);
}
}
Salida
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]
Nota :Mientras realiza el copy() método ambas listas deben ser del mismo tamaño.
4. Búsqueda usando binarySearch()
El binarySearch() El método del marco de colecciones de Java busca el elemento especificado. Devuelve la posición del elemento en las colecciones especificadas. Por ejemplo,
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);
}
}
Salida
The position of 3 is 2.
Nota :La colección debe ordenarse antes de realizar el binarySearch() método.
Para obtener más información, visite Búsqueda binaria de Java.
5. Composición
frequency()- devuelve el recuento de la cantidad de veces que un elemento está presente en la coleccióndisjoint()- comprueba si dos colecciones contienen algún elemento común
Por ejemplo,
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);
}
}
Salida
ArrayList1: [1, 2, 3, 2] Count of 2: 2 ArrayList2: [5, 6] Two lists are disjoint: true
6. Encontrar valores extremos
El min() y max() Los métodos del marco de colecciones de Java se utilizan para encontrar los elementos mínimo y máximo, respectivamente. Por ejemplo,
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);
}
}
Salida
Minimum Element: 1 Maximum Element: 3
Java