Programa Java para verificar los límites de la array al ingresar elementos en la array

Concepto: Los arreglos son estructuras de datos estáticas y no crecen automáticamente con un número creciente de elementos. Con arrays, es importante especificar el tamaño de la array en el momento de la declaración. En Java, cuando intentamos acceder a un índice de array más allá del rango de la array, arroja una excepción ArrayIndexOutOfBounds. Una excepción es una obstrucción a la ejecución normal del programa. Java tiene bloques try-catch-finally para un manejo de excepciones eficiente. ArrayIndexOutOfBoundsException es una excepción de tiempo de ejecución y debe manejarse con cuidado para evitar la terminación abrupta del programa. 

Enfoques:

1. Uso del bloque try-catch donde la entrada se toma más allá del rango del índice de array
2. Uso del bloque try-catch donde la entrada se toma dentro del rango de índice de array
3. Uso de restricciones sobre la entrada del usuario 

Primer enfoque

En el primer enfoque, se declara una array de tamaño = 5. La entrada se toma dentro de un bloque de prueba y el bucle se ejecuta 6 veces. Dado que el tamaño de la array es 5, después de la sexta entrada se lanza una ArrayIndexOutOfBoundsException . La excepción es manejada por el bloque catch. El código para manejar la excepción se coloca dentro del bloque catch. En este ejemplo, notificamos al usuario que se ha producido una excepción y que la entrada supera el rango de la array.

Implementación : en todos los enfoques, se utiliza la variable denominada ‘i’ del tipo de datos entero que se ha tenido en cuenta.

// Importing generic Classes/Files
import java.util.*;
 
public class GFG {
 
    // Main driver method
    public static void main(String args[])
        throws ArrayIndexOutOfBoundsException
    {
 
        // Taking input from user
        Scanner s = new Scanner(System.in);
 
        // Storing user input elements in an array
        int arr[] = new int[5];
 
        // Try block to check exception
        try {
            // Forcefully iteration loop no of times
            // these no of times > array size
            for (int i = 0; i < 6; i++) {
 
                // Storing elements through nextInt()
                arr[i] = s.nextInt();
            }
        }
        catch (ArrayIndexOutOfBoundsException e) {
            // Print message when any exception occurs
            System.out.println(
                "Array Bounds Exceeded...\nTry Again");
        }
    }
}

Producción:

Segundo enfoque

En el segundo enfoque, declaramos una array de tamaño = 5. La entrada se toma dentro de un bucle while dentro de un bloque de prueba. El valor de i se compara con el tamaño de la array en cada iteración. El valor de ‘i’ se inicia con 0 y puede recibir entradas hasta el índice 4. Tan pronto como el valor de ‘i’ llega a 5, se lanza una excepción. Esta excepción es manejada por el bloque catch. Este método es similar al primero, sin embargo, en este enfoque, no se toma ninguna entrada más allá del rango del índice de array, lo que no era el caso en el primer enfoque.

Implementación:

// Importing generic Classes/Files
import java.util.*;
 
public class GFG {
 
    // Main driver method
    public static void main(String args[])
        throws ArrayIndexOutOfBoundsException
    {
 
        // Taking input from user
        Scanner s = new Scanner(System.in);
        // Storing elements as array
        int arr[] = new int[5];
 
        / variable created and initialized with 0 int i = 0;
 
        // try block to check exception
        try {
 
            // Condition check
            while (true) {
                if (i == 5)
 
                    // Statement responsible for exception
                    throw new ArrayIndexOutOfBoundsException();
                arr[i++] = s.nextInt();
            }
        }
 
        // Catch block to handle exception
        catch (ArrayIndexOutOfBoundsException e) {
 
            // Message printed when exception occurs
            System.out.println(
                "Array Bounds Exceeded...\nTry Again");
        }
    }
}

Producción:

Tercer enfoque

En este enfoque, no usamos el concepto de manejo de excepciones sino que limitamos la entrada usando bucles. Es un método más fácil y conveniente para verificar los límites de la array mientras recibe entradas del usuario.

Implementación:

// Importing Classes/Files
import java.util.*;
 
public class GFG {
 
    // Main driver code
    public static void main(String args[])
    {
 
        // Taking user input through scanner
        Scanner s = new Scanner(System.in);
 
        // Creating array to store elements
        int arr[] = new int[5];
 
        // creating and initializing variable with 0
        int i = 0;
 
        // Condition check
        while (i < 5) {
 
            // Storing user defined elements in array
            arr[i++] = s.nextInt();
        }
        System.out.println(
            "Array elements are as follows: ");
 
        // Iteration over elements
        for (int j = 0; j < 5; j++)
            System.out.print(arr[j] + "  ");
    }
}

Producción: