Header Ads Widget

Ticker

6/recent/ticker-posts

Algoritmos Java

En este tutorial, aprenderemos sobre los diferentes algoritmos proporcionados por el marco de colecciones de Java con la ayuda de ejemplos.
anuncios a través de carbonoMongoDB Atlas es el servicio de base de datos en la nube más confiable disponible. ¡Probar ahora!ANUNCIOS A TRAVÉS DE CARBONO
El marco de colecciones de Java proporciona varios algoritmos que pueden usarse para manipular elementos almacenados en estructuras de datos.
Los algoritmos en Java son métodos estáticos que se pueden usar para realizar diversas operaciones en colecciones.
Dado que los algoritmos se pueden usar en varias colecciones, estos también se conocen como algoritmos genéricos .
Veamos la implementación de diferentes métodos disponibles en el marco de colecciones.

1. Ordenar usando sort ()

El sort()método proporcionado por el marco de colecciones se utiliza para ordenar elementos. Por ejemplo,
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating an array list
  6. ArrayList<Integer> numbers = new ArrayList<>();
  7. // Add elements
  8. numbers.add(4);
  9. numbers.add(2);
  10. numbers.add(3);
  11. System.out.println("Unsorted ArrayList: " + numbers);
  12. // Using the sort() method
  13. Collections.sort(numbers);
  14. System.out.println("Sorted ArrayList: " + numbers);
  15. }
  16. }
Salida
ArrayList sin clasificar: [4, 2, 3]
Lista de matriz ordenada: [2, 3, 4]
Aquí la clasificación se produce en orden natural (orden ascendente). Sin embargo, podemos personalizar el orden de clasificación del sort()método utilizando la interfaz Comparator .
Para obtener más información, visite Java Sorting .

2. Barajar usando barajar ()

El shuffle()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,
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating an array list
  6. ArrayList<Integer> numbers = new ArrayList<>();
  7. // Add elements
  8. numbers.add(1);
  9. numbers.add(2);
  10. numbers.add(3);
  11. System.out.println("Sorted ArrayList: " + numbers);
  12. // Using the shuffle() method
  13. Collections.shuffle(numbers);
  14. System.out.println("ArrayList using shuffle: " + numbers);
  15. }
  16. }
Salida
Lista de matriz ordenada: {1, 2, 3}
ArrayList usando 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 donde queremos resultados aleatorios.

3. Manipulación de datos de rutina

En Java, el marco de colecciones proporciona diferentes métodos que pueden usarse para manipular datos.
  • reverse() - invierte el orden de los elementos
  • fill() - Reemplazar cada elemento de una colección con el valor especificado
  • copy() - crea una copia de elementos del origen especificado al destino
  • swap() - intercambia la posición de dos elementos en una colección
  • addAll() - agrega todos los elementos de una colección a otra colección
Por ejemplo,
  1. import java.util.Collections;
  2. import java.util.ArrayList;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating an ArrayList
  6. ArrayList<Integer> numbers = new ArrayList<>();
  7. numbers.add(1);
  8. numbers.add(2);
  9. System.out.println("ArrayList1: " + numbers);
  10. // Using reverse()
  11. Collections.reverse(numbers);
  12. System.out.println("Reversed ArrayList1: " + numbers);
  13. // Using swap()
  14. Collections.swap(numbers, 0, 1);
  15. System.out.println("ArrayList1 using swap(): " + numbers);
  16. ArrayList<Integer> newNumbers = new ArrayList<>();
  17. // Using addAll
  18. newNumbers.addAll(numbers);
  19. System.out.println("ArrayList2 using addAll(): " + newNumbers);
  20. // Using fill()
  21. Collections.fill(numbers, 0);
  22. System.out.println("ArrayList1 using fill(): " + numbers);
  23. // Using copy()
  24. Collections.copy(newNumbers, numbers);
  25. System.out.println("ArrayList2 using copy(): " + newNumbers);
  26. }
  27. }
Salida
ArrayList1: [1, 2]
ArrayList1 invertido1: [2, 1]
ArrayList1 Usando swap (): [1, 2]
ArrayList2 usando addALl (): [1, 2]
ArrayList1 usando fill (): [0, 0]
ArrayList2 usando copy (): [0, 0]
Nota : Al realizar el copy()método, ambas listas deben ser del mismo tamaño.

4. Búsqueda usando binarySearch ()

El binarySearch()método del marco de colecciones de Java busca el elemento especificado. Devuelve la posición del elemento en las colecciones especificadas. Por ejemplo,
  1. import java.util.Collections;
  2. import java.util.ArrayList;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating an ArrayList
  6. ArrayList<Integer> numbers = new ArrayList<>();
  7. numbers.add(1);
  8. numbers.add(2);
  9. numbers.add(3);
  10. // Using binarySearch()
  11. int pos = Collections.binarySearch(numbers, 3);
  12. System.out.println("The position of 3 is " + pos);
  13. }
  14. }
Salida
La posición de 3 es 2.
Nota : La colección debe ordenarse antes de realizar el binarySearch()método.
Para saber más, visite Java Binary Search .

5. Composición

  • frequency() - devuelve el recuento de la cantidad de veces que un elemento está presente en la colección
  • disjoint() - comprueba si dos colecciones contienen algún elemento común
Por ejemplo,
  1. import java.util.Collections;
  2. import java.util.ArrayList;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating an ArrayList
  6. ArrayList<Integer> numbers = new ArrayList<>();
  7. numbers.add(1);
  8. numbers.add(2);
  9. numbers.add(3);
  10. numbers.add(2);
  11. System.out.println("ArrayList1: " + numbers);
  12. int count = Collections.frequency(numbers, 2);
  13. System.out.println("Count of 2: " + count);
  14. ArrayList<Integer> newNumbers = new ArrayList<>();
  15. newNumbers.add(5);
  16. newNumbers.add(6);
  17. System.out.println("ArrayList2: " + newNumbers);
  18. boolean value = Collections.disjoint(numbers, newNumbers);
  19. System.out.println("Two lists are disjoint: " + value);
  20. }
  21. }
Salida
ArrayList1: [1, 2, 3, 2]
Cuenta de 2: 2
ArrayList2: [5, 6]
Dos listas son disjuntas: verdadero

6. Encontrar valores extremos

Los métodos min()max()del marco de colecciones de Java se utilizan para encontrar los elementos mínimo y máximo, respectivamente. Por ejemplo,
  1. import java.util.Collections;
  2. import java.util.ArrayList;
  3. class Main {
  4. public static void main(String[] args) {
  5. // Creating an ArrayList
  6. ArrayList<Integer> numbers = new ArrayList<>();
  7. numbers.add(1);
  8. numbers.add(2);
  9. numbers.add(3);
  10. // Using min()
  11. int min = Collections.min(numbers);
  12. System.out.println("Minimum Element: " + min);
  13. // Using max()
  14. int max = Collections.max(numbers);
  15. System.out.println("Maximum Element: " + max);
  16. }
  17. }
Salida
Elemento mínimo: 1
Elemento Máximo: 3

Publicar un comentario

0 Comentarios