Una colección es un grupo de objetos individuales representados como una sola unidad. Java proporciona Collection Framework que define varias clases e interfaces para representar un grupo de objetos como una sola unidad. Estos son:
Encontrar el elemento mínimo y máximo de una colección se puede hacer fácilmente usando el método Collections.min() y Collections.max(). Estos son métodos estáticos de la clase de colecciones en Java. Por lo tanto, se puede acceder a ellos directamente con la ayuda del nombre de la clase, como se muestra a continuación.
Object ob = Collections.min(Collection<E> c); Object ob = Collections.max(Collection<E> c);
Como se ve en la sintaxis anterior, los métodos Collections.min() y Collections.max() toman la colección como parámetro. Esta es la colección de la que se encuentra el elemento máximo/mínimo. Por lo tanto, cualquier clase que implemente la interfaz Collection se puede pasar como parámetro en estas funciones, como Arrays, LinkedList, ArrayList, Set, etc. Y, por lo tanto, se puede encontrar fácilmente el elemento máximo y mínimo de cualquier colección.
Los siguientes ejemplos demuestran el procedimiento para encontrar el elemento mínimo y máximo de algunas de las colecciones.
Ejemplo 1: en la lista
// Java program to find the minimum and
// maximum element in a List
import java.util.*;
public class GFG {
public static void main(String args[]) throws Exception
{
// Get the ArrayList
List<Integer> list = new ArrayList<Integer>();
// populate the list
list.add(12);
list.add(53);
list.add(30);
list.add(8);
// printing the List
System.out.println("List: " + list);
// getting minimum value
// using min() method
int minList = Collections.min(list);
// getting maximum value
// using max() method
int maxList = Collections.max(list);
// printing the minimum value
System.out.println("Minimum value of list is: "
+ minList);
// printing the maximum value
System.out.println("Maximum value of list is: "
+ maxList);
}
}
List: [12, 53, 30, 8] Minimum value of list is: 8 Maximum value of list is: 53
Ejemplo 2: en conjunto
// Java program to find the minimum and
// maximum element in a Set
import java.util.*;
public class GFG {
public static void main(String args[]) throws Exception
{
// Get the HashSet
Set<Integer> set = new HashSet<Integer>();
// fill the hashSet
set.add(3);
set.add(6);
set.add(2);
set.add(9);
// printing the Set
System.out.println("Set: " + set);
// getting minimum value
// using min() method
int minSet = Collections.min(set);
// getting maximum value
// using max() method
int maxSet = Collections.max(set);
// printing the minimum value
System.out.println("Minimum value of set is: "
+ minSet);
// printing the maximum value
System.out.println("Maximum value of set is: "
+ maxSet);
}
}
Set: [2, 3, 6, 9] Minimum value of set is: 2 Maximum value of set is: 9
Ejemplo 3: en arreglos
// Java program to find the minimum and
// maximum element in an Array
import java.util.*;
public class GFG {
public static void main(String args[]) throws Exception
{
// Get the Array
Integer arr[] = { 2, 5, 1, 8, 34, 20, 4 };
// printing the Array
System.out.println("Array: " + Arrays.toString(arr));
// getting minimum value
// using min() method
int minArray = Collections.min(Arrays.asList(arr));
// getting maximum value
// using max() method
int maxArray
= Collections.max(Arrays.asList(arr));
// printing the minimum value
System.out.println("Minimum value of Array is: "
+ minArray);
// printing the maximum value
System.out.println("Maximum value of Array is: "
+ maxArray);
}
}
Array: [2, 5, 1, 8, 34, 20, 4] Minimum value of Array is: 1 Maximum value of Array is: 34
¿Qué pasará si la colección es un Mapa?
El mapa es un tipo diferente de entidad en Java Collection Framework en el que los elementos se toman como
Ejemplo:
// Java program to find the minimum and
// maximum element in a Map
import java.util.*;
public class GFG {
public static void main(String args[]) throws Exception
{
try {
// Creating hashMap
Map<String, Integer> map
= new HashMap<String, Integer>();
// Putting key-value pairs in map
map.put("A", 10);
map.put("B", 15);
map.put("C", 20);
map.put("D", 25);
// Print the map
System.out.println("Map: " + map);
// getting minimum value using min()
int minMap = Collections.min(map);
// getting maximum value using max()
int maxMap = Collections.max(map);
// printing the minimum value
System.out.println("Minimum value of Map is: "
+ minMap);
// printing the maximum value
System.out.println("Maximum value of Map is: "
+ maxMap);
}
catch (NoSuchElementException e) {
System.out.println("Exception: " + e);
}
}
}
Compile Errors: prog.java:25: error: no suitable method found for min(Map) int minMap = Collections.min(map); ^ method Collections. min(Collection) is not applicable
¿Cómo encontrar el elemento mínimo y máximo de un mapa?
Aunque Map no implementa la Interfaz de colección, pero el tipo de elemento de Mapa, es decir, la clase Clave y Valor , implementa la Interfaz de colección individualmente . Por lo tanto, el elemento Mínimo y Máximo se puede encontrar en el Mapa en función de su Clave o Valor.
Ejemplo 1: Para encontrar elementos mínimos y máximos del Mapa basados en los Valores Clave.
// Java program to find the minimum and
// maximum element in a Map
import java.util.*;
public class GFG {
public static void main(String args[]) throws Exception
{
// Creating hashMap
Map<String, Integer> map
= new HashMap<String, Integer>();
// Putting key-value pairs in map
map.put("A", 10);
map.put("B", 15);
map.put("C", 20);
map.put("D", 25);
// Print the map
System.out.println("Map: " + map);
// getting minimum value using min()
String minKey = Collections.min(map.keySet());
// getting maximum value using max()
String maxKey = Collections.max(map.keySet());
// printing the minimum value
System.out.println("Minimum Key of Map is: "
+ minKey);
System.out.println("Value corresponding to "
+ "minimum Key of Map is: "
+ map.get(minKey));
// printing the maximum value
System.out.println("Maximum Key of Map is: " + maxKey);
System.out.println("Value corresponding to "
+ "maximum Key of Map is: "
+ map.get(maxKey));
}
}
Map: {A=10, B=15, C=20, D=25}
Minimum Key of Map is: A
Value corresponding to minimum Key of Map is: 10
Maximum Key of Map is: D
Value corresponding to maximum Key of Map is: 25
Ejemplo 2: Para encontrar elementos mínimos y máximos del Mapa basado en las Claves de Valor.
// Java program to find the minimum and
// maximum element in a Map
import java.util.*;
public class GFG {
public static void main(String args[]) throws Exception
{
// Creating hashMap
Map<String, Integer> map
= new HashMap<String, Integer>();
// Putting key-value pairs in map
map.put("A", 10);
map.put("B", 15);
map.put("C", 20);
map.put("D", 25);
// Print the map
System.out.println("Map: " + map);
// getting minimum value using min()
int minValue = Collections.min(map.values());
// getting maximum value using max()
int maxValue = Collections.max(map.values());
// printing the minimum value
System.out.println("Minimum Value of Map is: "
+ minValue);
// printing the maximum value
System.out.println("Maximum Value of Map is: "
+ maxValue);
}
}
Map: {A=10, B=15, C=20, D=25}
Minimum Value of Map is: 10
Maximum Value of Map is: 25
Publicación traducida automáticamente
Artículo escrito por Prashasti Baranwal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA