Encontrar el valor mínimo o máximo en Java ArrayList

El valor mínimo es el que tiene el valor más pequeño y el valor máximo es el que tiene el valor más grande. La tarea principal aquí es encontrar el valor mínimo y máximo de ArrayList . Considere un ejemplo de ArrayList, y necesitamos encontrar el elemento más grande y el más pequeño. 

Ejemplo:

Input List: {10, 20, 8, 32, 21, 31};

Output: 

Maximum is: 32

Minimum is: 8

Método 1: iterando sobre los valores de ArrayList

1. Primero, necesitamos inicializar los valores de ArrayList.
2. Luego, la longitud de ArrayList se puede encontrar usando la función size() .
3. Después de eso, el primer elemento de ArrayList se almacenará en las variables min y max.
4. Luego, el ciclo for se usa para iterar a través de los elementos de ArrayList uno por uno para encontrar el mínimo y el máximo de la lista de arreglos.

// Java program to find the minimum and
// maximum value of the ArrayList
  
import java.util.*;
public class Max {
    public static void main(String args[])
    {
  
        // initializing the ArrayList elements
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(10);
        arr.add(20);
        arr.add(8);
        arr.add(32);
        arr.add(21);
        arr.add(31);
  
        int min = arr.get(0);
        int max = arr.get(0);
  
        // store the length of the ArrayList in variable n
        int n = arr.size();
  
        // loop to find minimum from ArrayList
        for (int i = 1; i < n; i++) {
            if (arr.get(i) < min) {
                min = arr.get(i);
            }
        }
  
        // loop to find maximum from ArrayList
        for (int i = 1; i < n; i++) {
            if (arr.get(i) > max) {
                max = arr.get(i);
            }
        }
  
        // The result will be printed
        System.out.println("Maximum is : " + max);
        System.out.println("Minimum is : " + min);
    }
}

Maximum is : 32
Minimum is : 8

Método 2: usar métodos de clase de colección

Podemos usar el método min() y max() de la clase de colección de Java. Las colecciones en Java son básicamente un marco que proporciona una arquitectura para acumular y manejar el grupo de objetos. El marco de Java Collection proporciona muchas clases, como ArrayList, Vector, LinkedList, PriorityQueue, HashSet, LinkedHashSet, TreeSet.

Acercarse:

1. Primero, necesitamos crear una clase.
2. Luego, se debe crear un ArrayList entero para almacenar los elementos. Después de eso, la longitud de ArrayList debe calcularse con la ayuda del método size().
3. La longitud de ArrayList se usará para iterar a través del ciclo e imprimir los elementos de ArrayList.
4. Luego, el método min y max de la clase de colección se usará para encontrar el mínimo y el máximo de ArrayList y se almacenará en la variable min y max y luego el resultado se imprimirá en la pantalla.

// Java program to find the minimum and
// maximum element of the list using
// Collection class's method
  
import java.util.ArrayList;
import java.util.Collections;
  
public class MinMax {
    public static void main(String args[])
    {
        // Creating arraylist
        ArrayList<Integer> arr = new ArrayList<Integer>();
  
        // Adding object in arraylist
        arr.add(10);
        arr.add(20);
        arr.add(5);
        arr.add(8);
  
        // Finding the size of ArrayList
        int n = arr.size();
  
        // printing the ArrayList elements
        System.out.println("ArrayList elements are :");
  
        for (int i = 0; i < n; i++) {
            System.out.print(arr.get(i) + " ");
        }
  
        System.out.println();
  
        // Finding the minimum and maximum from the
        // arraylist using min and max method of collection
        // class
  
        int max = Collections.max(arr);
        System.out.println("Maximum is : " + max);
  
        int min = Collections.min(arr);
        System.out.println("Minimum is : " + min);
    }
}

Array elements are :
10 20 5 8 
Maximum is : 20
Minimum is : 5

 Método 3: ordenando ArrayList

1. Primero, necesitamos importar la clase Collections, porque en la clase Collections hay un método llamado Collections.sort() que necesitamos para ordenar la array no ordenada.
2. Después de eso, se creará la ArrayList de enteros y luego calcularemos la longitud usando la función size() .
3. Luego, ArrayList se ordenará utilizando la función predefinida y, de forma predeterminada, se ordenará solo en orden creciente.
4. Para encontrar los valores mínimos y máximos de ArrayList, simplemente necesitamos encontrar el primer y último elemento de ArrayList, porque ArrayList está ordenado en orden ascendente, entonces el primer elemento será el más pequeño y el último será el más grande entre todos. los elementos.
5. El primer elemento se puede encontrar usando arr.get(0) , porque está presente en la primera posición y el índice de la array se inicia desde 0.
6. El último elemento se puede encontrar usando arr.get(n-1) , ya que n es el tamaño de la array y el índice de la array se inicia desde 0, por eso necesitamos encontrar el elemento que está en el índice n-1. Además, esta es una ArrayList ordenada, entonces el elemento más grande está presente al final.

// Java program to get the minimum and
// maximum value after the sorting the ArrayList
// using Collection class function
  
import java.util.*;
import java.util.Collections;
  
public class MaxMinSort {
    public static void main(String args[])
    {
        // Creating arraylist
        ArrayList<Integer> arr = new ArrayList<Integer>();
  
        // Adding object in arraylist
        arr.add(10);
        arr.add(12);
        arr.add(5);
        arr.add(8);
        arr.add(21);
        arr.add(16);
        arr.add(15);
  
        // Storing the size of the ArrayList in variable n
        int n = arr.size();
        int i;
  
        System.out.println("Elements of the ArrayList : ");
  
        for (i = 0; i < n; i++) {
            System.out.print(arr.get(i) + " ");
        }
  
        System.out.println();
  
        // The ArrayList will be sorted using predefined
        // function
        Collections.sort(arr);
  
        System.out.println("ArrayList after sorting : ");
  
        for (i = 0; i < n; i++) {
            System.out.print(arr.get(i) + " ");
        }
  
        System.out.println();
  
        // First and last element of the ArrayList gets stored
        // into min and max variable
        int min = arr.get(0);
        int max = arr.get(n - 1);
  
        System.out.println("Maximum is : " + max);
        System.out.println("Minimum is : " + min);
    }
}

Elements of the array : 
10 12 5 8 21 16 15 
Arrays after sorting : 
5 8 10 12 15 16 21 
Maximum is : 21
Minimum is : 5