Java ArrayIndexOutOfBoundsException

Java ArrayIndexOutOfBoundsException est produite lors de l'accès aux éléments du tableau au-delà d'une longueur prédéfinie. Les tableaux sont estimés à l'heure de leur confirmation, et ils sont de nature statique. Lorsque nous définissons un tableau, le nombre d'éléments est fixe, et il commence à 0. Par exemple, s'il y a 10 éléments, le tableau reconnaît le 10^ème élément comme le 11^ème élément car le premier élément est le 0^ème élément. Au début, tout programmeur pense qu’une fois le programme exécuté, le résultat est garanti. Mais il existe des problèmes soulevés par le système qui empêchent l'exécution du programme au moment de l'exécution, et ces problèmes sont qualifiés d'exceptions. Par conséquent, lorsque cette IndexOutOfBoundsException se produit pendant l'exécution, elle est produite à partir de la classe RuntimeException, qui à son tour est une sous-classe de la classe Main Exception, et toutes celles-ci sont dérivées du package java.lang.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Constructeurs

Les constructeurs sont formés lorsqu'une interface est implémentée à partir d'ArrayOutOfBoundsException. Il existe 3 types de constructeurs ArrayIndexOutOfBoundsException,

• ArrayIndexOutOfBoundsException() : Il construit ArrayIndexOutOfBoundsException sans aucun détail depuis la console.
• ArrayIndexOutOfBoundsException(int index): La variable index représente un autre index qui n'est pas légal, et construit ainsi une ArrayIndexOutOfBoundsException.
• ArrayIndexOutOfBoundsException(Strings): ArrayIndexOutOfBoundsException est construit avec n'importe quel message approprié.

Exemples d'implémentation de Java ArrayIndexOutOfBoundsException

Vous trouverez ci-dessous des exemples mentionnés :

Exemple n°1

Création d'une exception ArrayOutOfBounds

Code :

public class Main
{
public static void main (String[] args)
{
String[] veggies = {"Onion", "Carrot", "Potato", "Tomato", "Cucumber", "Radish"};
for (int i=0; i<=veggies.length; i++)
{
System.out.print (veggies[i] + " ");
}
}
}

Sortie :

Dans le programme ci-dessus, nous voyons que le tableau appelé légumes est composé de 6 éléments. Une fois la boucle for itérée, elle considère la condition I <=veggies.length, ce qui signifie que le tableau considère les éléments de la 0^ème position jusqu'à la 6^ème position et enfin , lors de la dernière itération, la valeur i=6 dépasse la taille du tableau, et par conséquent, l'ArrayoutOfBoundsException est implémentée.

Exemple n°2

Accès à ArrayOutOfBoundsException pour un index négatif

Code #1

public class Main {
public static void main (String[] args)
{
Integer[] intArray = {5, 7, 9, 11, 13, 15};
System.out.println ( "First element: " + intArray[0]);
System.out.println ( "Last element: " + intArray[-8]);
}
}

Sortie :

Ici, nous déclarons d'abord un tableau d'entiers, puis nous examinons comment accéder aux éléments individuels du tableau. Une fois cela fait, nous essayons d'imprimer le premier élément en donnant la commande intArray[0]. Ceci reconnaît le 0^ème élément, qui vaut 5 et l'imprime donc. D'un autre côté, nous fournissons également une commande pour imprimer un index négatif sous la forme -8. Par conséquent, le système ne parvient pas à reconnaître cet index et l'ArrayOutOfBoundsException est donc imprimée dans la sortie.

Code #2

public class MyClass {
int x;
public MyClass () {
x = 5;
}
public static void main (String[] args) {
MyClass myObj = new MyClass ();
System.out.println (myObj.x);
}
}

Sortie :

Comment éviter l'exception ArrayIndexOutOfBounds ?

Chaque programmeur commet une erreur en implémentant les indices et les éléments du tableau. Pour ces raisons, une ArrayIndexOutOfBoundsException s'est produite. Nous pouvons éviter ces erreurs en suivant les étapes ci-dessous.

1. Boucle for améliorée

Une boucle améliorée parcourt les territoires de mémoire adjacents comme les tableaux et accède simplement aux index légaux. À partir de ce moment-là, lorsque la boucle for améliorée est implémentée, nous n'avons plus à nous soucier de l'accès à des indices malavisés ou illégaux.

Code :

class Main {
public static void main (String[] args)
{
String[] fruits = {"Apple", "Mango", "Banana", "Watermelon", "Papaya"};
System.out.println ( "");
for (String strval:fruits)
{
System.out.print (strval + " ");
}
}
}

Sortie :

Nous avons utilisé une boucle for améliorée dans le programme ci-dessus pour parcourir la gamme de fruits. Tout d’abord, nous décrivons les 5 éléments du tableau, puis implémentons la boucle for améliorée. Cette boucle itère jusqu'à ce que la fin du tableau soit atteinte, et nous n'avons pas besoin de définir chaque tableau séparément. Ainsi, il passe en revue uniquement les indices ou éléments valides et fournit finalement le résultat exact de ce que nous recherchons. Par conséquent, nous pouvons éviter l'ArrayIndexOutOfBoundsException en utilisant cette boucle for améliorée.

2. Proper Start and End Indices

Arrays reliably start with list 0 and not 1. Moreover, the last part in the array can be gotten to using the record ‘arraylength-1’ and not ‘arraylength’. Programming engineers should be mindful while using beyond what many would consider possible and, as such, keep up a key good way from ArrayIndexOutOfBoundsException.

3. Type-Safe Iterator

Type-safe iterators do not toss an exception when they emphasise an assortment and make changes to it as they depict the assortment and roll out the improvements to it.

Code:

import java.util.HashMap;
public class MyClass {
public static void main (String[] args) {
HashMap<String, String> countries = new HashMap<String, String> ();
countries.put ( "India", "Delhi");
countries.put ( "Switzerland", "Bern");
countries.put ( "France", "Paris");
countries.put ( "Belgium", "Brussels");
System.out.println (countries);
}
}

Output:

Explanation: In the above program, we declare the string of cities and countries and declare that to the HashMap. The system then recognizes this assortment, iterates the code, and finally produces the output without throwing an ArrayIndexOutOfBoundsException.

Conclusion

The ArrayIndexOutOfBoundsException in Java usually occurs when we try to access the elements which are greater than the array length. These exceptions can be avoided by using enhanced for loops or proper indices. There are also exceptions called NullPointerExceptions that are not checked and go beyond RuntimeException; it does not urge the software engineer to utilize the catch square to deal with it. Therefore, we should keep in mind that we should not go beyond array limits and also avoid NegativeArraySizeException.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!