Cómo verificar si un array contiene solo números positivos en Java

Introducción

En este laboratorio, aprenderás cómo verificar si un array contiene solo números positivos en Java. Exploraremos diferentes enfoques para lograr esto, comenzando con un método fundamental que utiliza un bucle para iterar a través del array y verificar cada elemento individualmente.

Después del método básico con bucle, profundizaremos en el uso de la API de Streams de Java, una forma más moderna y a menudo más concisa de procesar colecciones. Finalmente, discutiremos cómo manejar los números cero y negativos en el contexto de determinar si un array contiene solo valores positivos. Este laboratorio te proporcionará habilidades prácticas en la manipulación de arrays y la lógica condicional en Java.

Skills Graph

Recorrer un array para verificar números positivos

En este paso, aprenderemos cómo iterar a través de un array de números en Java y verificar si cada número es positivo. Esta es una operación fundamental en la programación que nos permite procesar colecciones de datos.

Primero, creemos un nuevo archivo Java llamado PositiveCheck.java en el directorio ~/project. Puedes hacer esto haciendo clic derecho en el Explorador de archivos de la izquierda y seleccionando "Nuevo archivo", luego escribiendo PositiveCheck.java.

Ahora, abre el archivo PositiveCheck.java en el editor y agrega el siguiente código:

public class PositiveCheck {

    public static void main(String[] args) {
        // Define an array of integers
        int[] numbers = {10, -5, 20, 0, 15, -8};

        // Loop through the array
        for (int i = 0; i < numbers.length; i++) {
            // Get the current number
            int currentNumber = numbers[i];

            // Check if the number is positive
            if (currentNumber > 0) {
                System.out.println(currentNumber + " is a positive number.");
            }
        }
    }
}

Desglosemos este código:

• public class PositiveCheck: Esto declara nuestra clase, que coincide con el nombre del archivo.
• public static void main(String[] args): Este es el método principal donde comienza la ejecución de nuestro programa.
• int[] numbers = {10, -5, 20, 0, 15, -8};: Esta línea declara un array de enteros llamado numbers e inicializa con algunos valores. Un array es una colección de elementos del mismo tipo de datos.
• for (int i = 0; i < numbers.length; i++): Este es un bucle for. Es una estructura de control que nos permite repetir un bloque de código varias veces.
  • int i = 0: Esto inicializa una variable contador i en 0.
  • i < numbers.length: Esta es la condición que se verifica antes de cada iteración. El bucle continúa mientras i sea menor que la longitud del array numbers. numbers.length nos da el número de elementos en el array.
  • i++: Esto incrementa el contador i en 1 después de cada iteración.
• int currentNumber = numbers[i];: Dentro del bucle, esta línea accede al elemento en el índice actual i del array numbers y lo almacena en una variable llamada currentNumber. Los índices de los arrays comienzan desde 0.
• if (currentNumber > 0): Esta es una declaración if. Verifica si el currentNumber es mayor que 0.
• System.out.println(currentNumber + " is a positive number.");: Esta línea se ejecuta solo si la condición if es verdadera (es decir, el número es positivo). Imprime el número positivo seguido del texto " is a positive number.".

Guarda el archivo PositiveCheck.java (Ctrl+S o Cmd+S).

Ahora, compilemos y ejecutemos este programa en la Terminal. Asegúrate de estar en el directorio ~/project.

Compila el código:

javac PositiveCheck.java

Si no hay errores, se creará un archivo PositiveCheck.class.

Ahora, ejecuta el código compilado:

java PositiveCheck

Deberías ver la salida mostrando solo los números positivos del array.

10 is a positive number.
20 is a positive number.
15 is a positive number.

Esto demuestra cómo usar un bucle for para iterar a través de un array y aplicar una condición a cada elemento. En el siguiente paso, exploraremos una forma más moderna de obtener un resultado similar utilizando la API de Streams de Java.

Utilizar la API de Streams para números positivos

En este paso, exploraremos una forma más moderna y a menudo más concisa de procesar colecciones en Java: la API de Streams. Introducida en Java 8, las Streams ofrecen una forma poderosa de realizar operaciones como filtrado, mapeo y reducción en colecciones de datos.

Modificaremos nuestro ejemplo anterior para utilizar Streams y encontrar los números positivos en el array.

Abre de nuevo el archivo PositiveCheck.java en el editor. Reemplaza el código existente con lo siguiente:

import java.util.Arrays;

public class PositiveCheck {

    public static void main(String[] args) {
        // Define an array of integers
        int[] numbers = {10, -5, 20, 0, 15, -8};

        // Use Stream API to filter and print positive numbers
        Arrays.stream(numbers) // 1. Create a stream from the array
              .filter(number -> number > 0) // 2. Filter for positive numbers
              .forEach(number -> System.out.println(number + " is a positive number (Stream).")); // 3. Process each positive number
    }
}

Veamos las nuevas partes de este código:

• import java.util.Arrays;: Necesitamos importar la clase Arrays para utilizar su método stream().
• Arrays.stream(numbers): Esta línea convierte nuestro array de int en un IntStream. Una Stream no es una estructura de datos en sí misma, sino una secuencia de elementos que se pueden procesar.
• .filter(number -> number > 0): Esta es una operación intermedia en la Stream. El método filter() toma un Predicate (una función que devuelve verdadero o falso) y mantiene solo los elementos para los cuales el predicado es verdadero. Aquí, number -> number > 0 es una expresión lambda, que es una forma concisa de escribir una función. Verifica si cada number en la Stream es mayor que 0.
• .forEach(number -> System.out.println(number + " is a positive number (Stream)."));: Esta es una operación terminal. Las operaciones terminales consumen la Stream y producen un resultado. El método forEach() realiza una acción para cada elemento en la Stream. Aquí, imprime cada número positivo junto con un mensaje.

Guarda el archivo PositiveCheck.java.

Ahora, compila y ejecuta el programa modificado en la Terminal:

javac PositiveCheck.java

java PositiveCheck

Deberías ver la misma salida que antes, pero con el mensaje actualizado:

10 is a positive number (Stream).
20 is a positive number (Stream).
15 is a positive number (Stream).

Esto demuestra cómo se puede utilizar la API de Streams para obtener el mismo resultado que el bucle for tradicional, a menudo con un código más legible y expresivo, especialmente para operaciones más complejas.

Manejar números cero y negativos

En los pasos anteriores, nos centramos en identificar números positivos. Ahora, expandamos nuestro programa para identificar también números cero y negativos. Esto nos dará una imagen más completa de los números en nuestro array.

Modificaremos de nuevo el archivo PositiveCheck.java para incluir comprobaciones para números cero y negativos utilizando primero el enfoque del bucle for tradicional, ya que a menudo es más fácil entender la lógica condicional con declaraciones if-else if-else.

Abre el archivo PositiveCheck.java en el editor. Reemplaza el código existente con lo siguiente:

public class PositiveCheck {

    public static void main(String[] args) {
        // Define an array of integers
        int[] numbers = {10, -5, 20, 0, 15, -8};

        // Loop through the array
        for (int i = 0; i < numbers.length; i++) {
            // Get the current number
            int currentNumber = numbers[i];

            // Check if the number is positive, negative, or zero
            if (currentNumber > 0) {
                System.out.println(currentNumber + " is a positive number.");
            } else if (currentNumber < 0) {
                System.out.println(currentNumber + " is a negative number.");
            } else {
                System.out.println(currentNumber + " is zero.");
            }
        }
    }
}

Esto es lo nuevo:

• else if (currentNumber < 0): Esta es una declaración else if. Verifica si el currentNumber es menor que 0, pero solo si la condición if anterior (currentNumber > 0) fue falsa.
• else: Esta es una declaración else. El código dentro del bloque else se ejecuta si ninguna de las condiciones if o else if precedentes es verdadera. En este caso, si el número no es mayor que 0 y no es menor que 0, debe ser 0.

Guarda el archivo PositiveCheck.java.

Ahora, compila y ejecuta el programa modificado en la Terminal:

javac PositiveCheck.java

java PositiveCheck

Ahora deberías ver una salida que categoriza cada número en el array:

10 is a positive number.
-5 is a negative number.
20 is a positive number.
0 is zero.
15 is a positive number.
-8 is a negative number.

Esto demuestra cómo usar declaraciones if-else if-else para manejar múltiples condiciones dentro de un bucle. Este es un patrón fundamental para la toma de decisiones en la programación.

También se pueden obtener resultados similares utilizando la API de Streams con técnicas más avanzadas como partitioningBy o múltiples operaciones filter, pero el bucle for con if-else if-else es un enfoque claro y sencillo para esta tarea específica, especialmente para los principiantes.

Resumen

En este laboratorio, aprendimos cómo verificar si un array contiene solo números positivos en Java. Exploramos dos métodos principales: iterar a través del array utilizando un bucle for y utilizar la API de Streams de Java.

Comenzamos creando una clase Java y utilizando un bucle for para examinar cada elemento en un array de enteros. Implementamos una comprobación condicional (if (currentNumber > 0)) para identificar e imprimir números positivos. Este enfoque fundamental demostró cómo acceder y procesar elementos individuales dentro de un array. Si bien el contenido proporcionado solo detalló el método del bucle, la estructura del laboratorio indica que los pasos posteriores cubrirían la API de Streams y el manejo de números cero/negativos, brindando una comprensión integral de diferentes técnicas para esta tarea de programación común.