Programa Java para encontrar el número impar máximo en una array usando Stream y Filter

Java 8 introdujo algunas características excelentes como Stream y Filter que simplifican enormemente tareas como leer datos y realizar operaciones como mínimo, máximo, suma y verificación condicional en ellos. En este programa, obtendremos el máximo de todos los números impares de una lista de enteros con la ayuda del método Java Stream and Filter.

Uso de bucles

En ausencia de Streams, podríamos lograr la tarea dada iterando a través de la lista y verificando si el número es impar. De ser cierto, comprobaríamos si es mayor que el número impar máximo hasta ahora. 

A continuación se muestra la implementación del enfoque:

// Java implementation to find
// the maximum odd number in array
  
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
  
class GFG {
      
      // Function to find the maximum 
      // odd number in array
    public static int maxOdd(List<Integer> list)
    {
        // Iterator for accessing the elements
        Iterator<Integer> it = list.iterator();
  
        int max = 0;
        while (it.hasNext()) {
            int num = it.next();
  
            // Adding the elements 
              // greater than 5
            if (num % 2 == 1) {
                if (num > max) {
                    max = num;
                }
            }
        }
  
        return max;
    }
      
      // Driver Code
    public static void main(String[] args)
    {
        List<Integer> list = new ArrayList<Integer>();
  
        list.add(11);
        list.add(43);
        list.add(56);
        list.add(82);
        list.add(51);
        list.add(29);
        list.add(10);
  
        System.out.println("Largest odd number: "
                           + maxOdd(list));
    }
}

Largest odd number: 51

Uso de transmisión y filtro

El filtro de flujo devuelve un flujo que consta de los elementos de este flujo que coinciden con el predicado dado. Esta es una operación intermedia. Estas operaciones siempre son perezosas, es decir, ejecutar una operación intermedia como filter() en realidad no realiza ningún filtrado, sino que crea una nueva secuencia que, cuando se recorre, contiene los elementos de la secuencia inicial que coinciden con el predicado dado.

A continuación se muestra la implementación del enfoque anterior:

// Java implementation to find 
// the maximum odd number
// in the array
  
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
  
class GFG {
      
      // Function to find the maximum odd
      // number in the list 
    public static int maxOdd(List<Integer> list)
    {
        // Converted to Stream
          // Filtering the odd number
          // Taking maximum out of those integers
        return list.stream()
            .filter(n -> n % 2 == 1)
            .max(Integer::compare)
            .orElse(0);
    }
      
      // Driver Code
    public static void main(String[] args)
    {
        List<Integer> list = new ArrayList<Integer>();
  
        list.add(11);
        list.add(43);
        list.add(56);
        list.add(82);
        list.add(51);
        list.add(29);
        list.add(10);
  
        System.out.println("Largest odd number: "
                           + maxOdd(list));
    }
}

Largest odd number: 51

Análisis de rendimiento:

• Complejidad de tiempo: O(N)
• Espacio Auxiliar: O(1)