How To Increase Array Size As User Enters Java

Java Plan to Bank check Assortment Bounds while Inputing Elements into the Assortment

Concept: Arrays are static information structures and do non grow automatically with an increasing number of elements. With arrays, information technology is of import to specify the array size at the time of the announcement. In Java, when we try to access an array index across the range of the assortment it throws an ArrayIndexOutOfBounds Exception. An exception is an obstacle to the normal plan execution. Java has try-catch-finally blocks for efficient Exception Handling. ArrayIndexOutOfBoundsException is a runtime exception and must be handled carefully to prevent precipitous termination of the program.

Approaches:

Using endeavour-catch block where input is taken beyond the assortment alphabetize range
Using try-take hold of block where input is taken inside the array index range
Using constraints over user input

First Approach

In the first approach, an array of size = v is alleged. The input is taken within a effort block and the loop is executed 6 times. Since the array size is v, later the 6th input an ArrayIndexOutOfBoundsException is thrown. The exception is handled by the catch block. The code to handle the exception is placed within the take hold of block. In this example, we notify the user that an exception has occurred and the input exceeds the array range.

Implementation: In all approaches variable named 'i' is used of integer information-type been taken for consideration.

Java

                import                java.util.*;              
                public                grade                GFG {              
                                public                static                void                main(String args[])              
                                throws                ArrayIndexOutOfBoundsException              
                                {              
                                Scanner southward =                                new                Scanner(Arrangement.in);              
                                int                arr[] =                                new                int                [                5                ];              
                                effort                {              
                                for                (                int                i =                                0                ; i <                                six                ; i++) {              
                                arr[i] = s.nextInt();              
                                }              
                                }              
                                catch                (ArrayIndexOutOfBoundsException e) {              
                                System.out.println(              
                                "Array Bounds Exceeded...\nTry Again"                );              
                                }              
                                }              
                }              

Output:

2d Arroyo

In the second approach, nosotros declare an array of size = v. The input is taken within a while loop inside a try block. The value of i is checked against the size of the array at every iteration. The value of 'i' is initiated with 0 and can have input upwardly to index iv. As before long equally the value of 'i' reaches five an exception is thrown. This exception is handled by the catch block. This method is like to the first one, withal, in this approach, no input is taken across the assortment index range which was not the case in the first approach.

Implementation:

Java

                import                coffee.util.*;              
                public                form                GFG {              
                                public                static                void                main(String args[])              
                                throws                ArrayIndexOutOfBoundsException              
                                {              
                                Scanner s =                                new                Scanner(System.in);              
                                int                arr[] =                                new                int                [                5                ];              
                                / variable created and initialized with                                0                int                i =                                0                ;              
                                effort                {              
                                while                (                truthful                ) {              
                                if                (i ==                                5                )              
                                throw                new                ArrayIndexOutOfBoundsException();              
                                arr[i++] = southward.nextInt();              
                                }              
                                }              
                                take hold of                (ArrayIndexOutOfBoundsException due east) {              
                                System.out.println(              
                                "Array Bounds Exceeded...\nTry Again"                );              
                                }              
                                }              
                }              

Output:

Third Arroyo

In this approach nosotros do not use the concept of exception handling rather we limit the input using loops. It is an easier and convenient method of checking array bounds while taking inputs from the user.

Implementation:

Java

                import                java.util.*;              
                public                class                GFG {              
                                public                static                void                chief(String args[])              
                                {              
                                Scanner south =                                new                Scanner(Arrangement.in);              
                                int                arr[] =                                new                int                [                v                ];              
                                int                i =                                0                ;              
                                while                (i <                                5                ) {              
                                arr[i++] = s.nextInt();              
                                }              
                                System.out.println(              
                                "Array elements are equally follows: "                );              
                                for                (                int                j =                                0                ; j <                                v                ; j++)              
                                Organisation.out.print(arr[j] +                                "  "                );              
                                }              
                }              