Wat veroorzaakt een java.lang.ArrayIndexOutOfBoundsException en hoe voorkom ik dit?

Wat betekent ArrayIndexOutOfBoundsExceptionen hoe kom ik er vanaf?

Hier is een codevoorbeeld dat de uitzondering activeert:

String[] names = { "tom", "bob", "harry" };
for (int i = 0; i <= names.length; i++) {
    System.out.println(names[i]);
}

Antwoord 1, autoriteit 100%

Uw eerste aanloophaven moet de documentatiewat het redelijk duidelijk uitlegt:

Gegooid om aan te geven dat een array is geopend met een illegale index. De index is ofwel negatief, ofwel groter dan of gelijk aan de grootte van de array.

Dus bijvoorbeeld:

int[] array = new int[5];
int boom = array[10]; // Throws the exception

Hoe je het kunt vermijden… eh, doe dat niet. Wees voorzichtig met uw array-indexen.

Een probleem waar mensen soms tegenaan lopen, is denken dat arrays 1-geïndexeerd zijn, bijvoorbeeld

int[] array = new int[5];
// ... populate the array here ...
for (int index = 1; index <= array.length; index++)
{
    System.out.println(array[index]);
}

Dat zal het eerste element (index 0) missen en een uitzondering genereren wanneer index 5 is. De geldige indexen hier zijn 0-4 inclusief. De juiste, idiomatische forverklaring hier zou zijn:

for (int index = 0; index < array.length; index++)

(Dat veronderstelt natuurlijk dat je de index nodignodig hebt. Als je in plaats daarvan de verbeterde for-lus kunt gebruiken, doe dat dan.)

Antwoord 2, autoriteit 17%

if (index < 0 || index >= array.length) {
    // Don't use this index. This is out of bounds (borders, limits, whatever).
} else {
    // Yes, you can safely use this index. The index is present in the array.
    Object element = array[index];
}

Zie ook:

• De Java-tutorials – Basistaal – Arrays

Update: volgens uw codefragment,

for (int i = 0; i<=name.length; i++) {

De index is inclusief de lengte van de array. Dit is buiten de perken. U moet <=vervangen door <.

for (int i = 0; i < name.length; i++) {

Antwoord 3, autoriteit 8%

Uit dit uitstekende artikel: ArrayIndexOutOfBoundsException in for loop

Om het kort te zeggen:

In de laatste iteratie van

for (int i = 0; i <= name.length; i++) {

iis gelijk aan name.lengthwat een illegale index is, aangezien array-indices op nul zijn gebaseerd.

Uw code zou moeten lezen

for (int i = 0; i < name.length; i++) 
                  ^

Antwoord 4, autoriteit 6%

Het betekent dat u toegang probeert te krijgen tot een index van een array die niet geldig is omdat deze niet tussen de grenzen ligt.

Dit zou bijvoorbeeld een primitieve integer-array initialiseren met de bovengrens 4.

int intArray[] = new int[5];

Programmeurs tellen vanaf nul. Dus dit zou bijvoorbeeld een ArrayIndexOutOfBoundsExceptionopleveren, aangezien de bovengrens 4 is en niet 5.

intArray[5];

Antwoord 5, autoriteit 4%

Wat veroorzaakt ArrayIndexOutOfBoundsException?

Als je een variabele ziet als een “vak” waar je een waarde in kunt plaatsen, dan is een array een reeks naast elkaar geplaatste vakken, waarbij het aantal vakken een eindig en expliciet geheel getal is.

Een array als volgt maken:

final int[] myArray = new int[5]

maakt een rij van 5 vakken, elk met een int. Elk van de dozen heeft een index, een positie in de reeks dozen. Deze index begint bij 0 en eindigt bij N-1, waarbij N de grootte van de array is (het aantal vakken).

Als u een van de waarden uit deze reeks vakken wilt ophalen, kunt u ernaar verwijzen via de index, als volgt:

myArray[3]

Hiermee krijgt u de waarde van de 4e box in de reeks (aangezien de eerste box index 0 heeft).

Een ArrayIndexOutOfBoundsExceptionwordt veroorzaakt door te proberen een “box” op te halen die niet bestaat, door een index door te geven die hoger is dan de index van de laatste “box”, of negatief.

Met mijn lopende voorbeeld zouden deze codefragmenten zo’n uitzondering produceren:

myArray[5] //tries to retrieve the 6th "box" when there is only 5
myArray[-1] //just makes no sense
myArray[1337] //waay to high

Hoe ArrayIndexOutOfBoundsException

Om ArrayIndexOutOfBoundsExceptionte voorkomen, zijn er enkele belangrijke punten om te overwegen:

Looping

Als u door een array loopt, zorg er dan altijd voor dat de index die u ophaalt strikt kleiner is dan de lengte van de array (het aantal vakken). Bijvoorbeeld:

for (int i = 0; i < myArray.length; i++) {

Let op de <, meng er nooit een =in..

Je zou in de verleiding kunnen komen om zoiets als dit te doen:

for (int i = 1; i <= myArray.length; i++) {
    final int someint = myArray[i - 1]

Gewoon niet doen. Houd je aan bovenstaande (als je de index moet gebruiken) en het zal je veel pijn besparen.

Gebruik waar mogelijk foreach:

for (int value : myArray) {

Op deze manier hoeft u helemaal niet aan indexen te denken.

Tijdens looping, wat je ook doet, verander NOOIT de waarde van de loop-iterator (hier: i). De enige plaats waar dit van waarde zou moeten veranderen, is om de lus in stand te houden. Als u het anders wijzigt, riskeert u alleen maar een uitzondering en is in de meeste gevallen niet nodig.

Ophalen/bijwerken

Als u een willekeurig element van de array ophaalt, controleer dan altijd of het een geldige index is ten opzichte van de lengte van de array:

public Integer getArrayElement(final int index) {
    if (index < 0 || index >= myArray.length) {
        return null; //although I would much prefer an actual exception being thrown when this happens.
    }
    return myArray[index];
}

Antwoord 6, autoriteit 4%

Om een ​​array-index out-of-bounds-uitzondering te vermijden, moet men de enhanced-forverklaring waar en wanneer ze kunnen.

De primaire motivatie (en use case) is wanneer u itereert en u geen ingewikkelde iteratiestappen nodig heeft. Je zou nietin staat zijn om een ​​verbeterde-forte gebruiken om achteruit te gaan in een array of alleen op elk ander element te herhalen.

Je zult gegarandeerd niet zonder elementen komen te zitten om te herhalen wanneer je dit doet, en je [gecorrigeerde] voorbeeld kan gemakkelijk worden omgezet.

De onderstaande code:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i< name.length; i++) {
    System.out.print(name[i] + "\n");
}

…is gelijk aan dit:

String[] name = {"tom", "dick", "harry"};
for(String firstName : name) {
    System.out.println(firstName + "\n");
}

Antwoord 7, autoriteit 2%

In je code heb je toegang gekregen tot de elementen van index 0 tot de lengte van de string-array. name.lengthgeeft het aantal string-objecten in je array van string-objecten, d.w.z. 3, maar je hebt slechts toegang tot index 2 name[2],
omdat de array toegankelijk is van index 0 tot name.length - 1waar je name.lengthaantal objecten krijgt.

Zelfs als je een for-lus gebruikt, ben je begonnen met index nul en moet je eindigen met name.length - 1. In een array a[n] heb je toegang van a[0] tot a[n-1].

Bijvoorbeeld:

String[] a={"str1", "str2", "str3" ..., "strn"};
for(int i=0; i<a.length(); i++)
    System.out.println(a[i]);

In jouw geval:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<=name.length; i++) {
    System.out.print(name[i] +'\n');
}

Antwoord 8, autoriteit 2%

Voor uw gegeven array is de lengte van de array 3(d.w.z. naam.lengte = 3). Maar aangezien het element opslaat vanaf index 0, heeft het max index 2.

Dus in plaats van ‘i**<=name.length’ moet je ‘i<**name.length’ schrijven om ‘ArrayIndexOutOfBoundsException’ te vermijden.

Antwoord 9

Tot zover deze eenvoudige vraag, maar ik wilde alleen een nieuwe functie in Java benadrukken die alle verwarring rond indexering in arrays zal voorkomen, zelfs voor beginners. Java-8 heeft de taak van iteratie voor u geabstraheerd.

int[] array = new int[5];
//If you need just the items
Arrays.stream(array).forEach(item -> { println(item); });
//If you need the index as well
IntStream.range(0, array.length).forEach(index -> { println(array[index]); })

Wat is het voordeel? Nou, een ding is de leesbaarheid zoals Engels. Ten tweede hoeft u zich geen zorgen te maken over de ArrayIndexOutOfBoundsException

Antwoord 10

U krijgt ArrayIndexOutOfBoundsExceptionvanwege het i<=name.lengthonderdeel. name.lengthretourneert de lengte van de tekenreeks name, die 3 is. Wanneer u dus probeert toegang te krijgen tot name[3], is dit illegaal en gooit een uitzondering.

Opgeloste code:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i < name.length; i++) { //use < insteadof <=
  System.out.print(name[i] +'\n');
}

Het is gedefinieerd in de Java taalspecificatie:

Het public finalveld length, dat het aantal componenten bevat
van de array. lengthkan positief of nul zijn.

Antwoord 11

Zo ziet dit type uitzondering eruit wanneer deze in Eclipse wordt gegooid. Het nummer in rood geeft de index aan die u probeerde te openen. Dus de code zou er als volgt uitzien:

myArray[5]

De fout treedt op wanneer u probeert toegang te krijgen tot een index die niet in die array voorkomt. Als een array een lengte heeft van 3,

int[] intArray = new int[3];

dan zijn de enige geldige indexen:

intArray[0]
intArray[1]
intArray[2]

Als een array een lengte heeft van 1,

int[] intArray = new int[1];

dan is de enige geldige index:

intArray[0]

Elk geheel getal gelijk aan de lengte van de array, of groter dan: is buiten de grenzen.

Elk geheel getal kleiner dan 0: valt buiten de grenzen;

PS: Als je een beter begrip van arrays wilt hebben en wat praktische oefeningen wilt doen, kun je hier een video bekijken: zelfstudie over arrays in Java

Antwoord 12

Voor multidimensionale arrays kan het lastig zijn om ervoor te zorgen dat u toegang krijgt tot de eigenschap lengthvan de juiste dimensie. Neem bijvoorbeeld de volgende code:

int [][][] a  = new int [2][3][4];
for(int i = 0; i < a.length; i++){
    for(int j = 0; j < a[i].length; j++){
        for(int k = 0; k < a[j].length; k++){
            System.out.print(a[i][j][k]);
        }
        System.out.println();
    }
    System.out.println();
}

Elke dimensie heeft een andere lengte, dus de subtiele fout is dat de middelste en binnenste lussen de eigenschap lengthvan dezelfde dimensie gebruiken (omdat a[i].lengthis hetzelfde als a[j].length).

In plaats daarvan moet de binnenste lus a[i][j].lengthgebruiken (of a[0][0].length, voor de eenvoud).

Antwoord 13

Het meest voorkomende geval dat ik heb gezien voor schijnbaar mysterieuze ArrayIndexOutOfBoundsExceptions, d.w.z. blijkbaar niet veroorzaakt door uw eigen array-verwerkingscode, is het gelijktijdige gebruik van SimpleDateFormat. Vooral in een servlet of controller:

public class MyController {
  SimpleDateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");
  public void handleRequest(ServletRequest req, ServletResponse res) {
    Date date = dateFormat.parse(req.getParameter("date"));
  }
}

Als twee threads de methode SimplateDateFormat.parse() samen invoeren, ziet u waarschijnlijk een ArrayIndexOutOfBoundsException. Let op het synchronisatiegedeelte van de class javadoc voor SimpleDateFormat.

Zorg ervoor dat er geen plaats in uw code is die toegang krijgt tot thread-onveilige klassen zoals SimpleDateFormat op een gelijktijdige manier zoals in een servlet of controller. Controleer alle instantievariabelen van uw servlets en controllers op mogelijke verdachten.

Antwoord 14

ArrayIndexOutOfBoundsException wanneer deze uitzondering binnenkomt, betekent dit dat u een index van array probeert te gebruiken die buiten zijn grenzen valt of in termen van leken dat u meer vraagt ​​dan u hebt geïnitialiseerd.

Om dit te voorkomen, moet u er altijd voor zorgen dat u geen index aanvraagt ​​die niet aanwezig is in de array, d.w.z. als de arraylengte 10 is, moet uw index tussen 0 en 9 liggen

Antwoord 15

ArrayIndexOutOfBounds betekent dat u een positie probeert te indexeren binnen een array die niet is toegewezen.

In dit geval:

String[] name = { "tom", "dick", "harry" };
for (int i = 0; i <= name.length; i++) {
    System.out.println(name[i]);
}

• name.length is 3 omdat de array is gedefinieerd met 3 String-objecten.
• Bij toegang tot de inhoud van een array begint positie vanaf 0. Aangezien er 3 items zijn, zou dit name[0]=”tom”, name[1]=”dick” en name[2]=”harry betekenen
• Als je een loop maakt, aangezien ikleiner kan zijn dan of gelijk is aan name.length, probeer je toegang te krijgen tot name[3] die niet beschikbaar is.

Om dit te omzeilen…

• In uw for-lus kunt u i < naam.lengte. Dit zou herhaling naar name[3] voorkomen en in plaats daarvan stoppen bij name[2]

  for(int i = 0; i<name.length; i++)

• Gebruik een voor elke lus

  String[] name = { "tom", "dick", "harry" };
for(String n : name) {
System.out.println(n);
}

• Gebruik list.forEach(actie van de consument) (vereist Java8)

  String[] name = { "tom", "dick", "harry" };
Arrays.asList(name).forEach(System.out::println);

• Array converteren naar stream – dit is een goede optie als u extra ‘bewerkingen’ aan uw array wilt uitvoeren, b.v. filter, transformeer de tekst, converteer naar een kaart etc (vereist Java8)

  String[] name = { "tom", "dick", "harry" };
--- Arrays.asList(name).stream().forEach(System.out::println);
--- Stream.of(name).forEach(System.out::println);

Antwoord 16

ArrayIndexOutOfBoundsExceptionbetekent dat u probeert toegang te krijgen tot een index van de array die niet bestaat of buiten de grens van deze array valt. Array-indexen beginnen bij 0en eindigen op lengte – 1.

In jouw geval

for(int i = 0; i<=name.length; i++) {
    System.out.print(name[i] +'\n'); // i goes from 0 to length, Not correct
}

ArrayIndexOutOfBoundsExceptiongebeurt wanneer u probeert toegang te krijgen
het geïndexeerde element name.length dat niet bestaat (array-index eindigt op lengte -1). gewoon <= vervangen door < zou dit probleem oplossen.

for(int i = 0; i < name.length; i++) {
    System.out.print(name[i] +'\n');  // i goes from 0 to length - 1, Correct
}

Antwoord 17

Voor elke array met lengte n hebben elementen van de array een index van 0 tot n-1.

Als uw programma toegang probeert te krijgen tot een element (of geheugen) met een array-index groter dan n-1, dan zal Java ArrayIndexOutOfBoundsException

genereren

Dus hier zijn twee oplossingen die we in een programma kunnen gebruiken

1. Tellen bijhouden:

   for(int count = 0; count < array.length; count++) {
       System.out.println(array[count]);
   }
   

   Of een andere lusverklaring zoals

   int count = 0;
   while(count < array.length) {
       System.out.println(array[count]);
       count++;
   }
   

2. Een betere manier om te gaan met een voor elke lus, bij deze methode hoeft een programmeur zich geen zorgen te maken over het aantal elementen in de array.

   for(String str : array) {
       System.out.println(str);
   }
   

Antwoord 18

Volgens uw code:

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<=name.length; i++) {
  System.out.print(name[i] +'\n');
}

Als u controleert
Systeem.uit.afdruk(naam.lengte);

je krijgt er 3;

dat betekent dat je naam 3 is

je lus loopt van 0 tot 3
die ofwel “0 to 2” of “1 to 3” zou moeten zijn

Antwoord

String[] name = {"tom", "dick", "harry"};
for(int i = 0; i<name.length; i++) {
  System.out.print(name[i] +'\n');
}

Antwoord 19

Elk item in een array wordt een element genoemd en elk element is toegankelijk via zijn numerieke index. Zoals in de voorgaande afbeelding te zien is, begint nummering met 0. Het 9e element zou daarom bijvoorbeeld toegankelijk zijn op index 8.

IndexOutOfBoundsException wordt gegenereerd om aan te geven dat een of andere index (zoals een array, een string of een vector) buiten bereik is.

Elke array X is toegankelijk van [0 tot (X.length – 1)]

Antwoord 20

Ik zie hier alle antwoorden waarin wordt uitgelegd hoe u met arrays werkt en hoe u uitzonderingen voor de index buiten de grenzen kunt vermijden. Persoonlijk vermijd ik arrays ten koste van alles. Ik gebruik de Collections-klassen, waardoor alle dwaasheden van het omgaan met array-indexen volledig worden vermeden. De lusconstructies werken prachtig met collecties die code ondersteunen die zowel gemakkelijker te schrijven, te begrijpen en te onderhouden is.

Antwoord 21

Als je de lengte van een array gebruikt om de iteratie van een for-lus te regelen, onthoud dan altijd dat de index van het eerste item in een array 0is. Dus de index van het laatste element in een array is één minder dan de lengte van de array.

Antwoord 22

ArrayIndexOutOfBoundsExceptionnaam zelf verklaart dat als u probeert toegang te krijgen tot de waarde bij de index die buiten het bereik van de arraygrootte valt, een dergelijk soort uitzondering optreedt.

In jouw geval kun je het gelijkteken gewoon uit je for-lus verwijderen.

for(int i = 0; i<name.length; i++)

De betere optie is om een ​​array te herhalen:

for(String i : name )
      System.out.println(i);

Antwoord 23

Deze fout treedt op bij overlimiettijden van de loop-lus. Laten we een eenvoudig voorbeeld als dit beschouwen,

class demo{
  public static void main(String a[]){
    int[] numberArray={4,8,2,3,89,5};
    int i;
    for(i=0;i<numberArray.length;i++){
        System.out.print(numberArray[i+1]+"  ");
    }
}

In eerste instantie heb ik een array geïnitialiseerd als ‘numberArray’. dan worden sommige array-elementen afgedrukt met for-lus. Wanneer loop ‘i’ time uitvoert, print dan het (numberArray[i+1] element..(wanneer i waarde 1 is 1, numberArray[i+1] element wordt afgedrukt.)..Stel dat, wanneer i=(numberArray. lengte-2), het laatste element van de array wordt afgedrukt..Als de ‘i’-waarde naar (numberArray.length-1) gaat, is er geen waarde voor afdrukken..In dat punt treedt ‘ArrayIndexOutOfBoundsException’ op. Ik hoop dat je kunt krijgen idee.dank je!

Antwoord 24

U kunt Optioneel gebruiken in functionele stijl om NullPointerExceptionen ArrayIndexOutOfBoundsExceptionte vermijden:

String[] array = new String[]{"aaa", null, "ccc"};
for (int i = 0; i < 4; i++) {
    String result = Optional.ofNullable(array.length > i ? array[i] : null)
            .map(x -> x.toUpperCase()) //some operation here
            .orElse("NO_DATA");
    System.out.println(result);
}

Uitvoer:

AAA
NO_DATA
CCC
NO_DATA

Antwoord 25

In de meeste programmeertaalindexen begint u vanaf 0. U moet dus in plaats daarvan i<names.lengthof i<=names.length-1schrijven van i<=names.length.

Antwoord 26

U kunt niet meer gegevens herhalen of opslaan dan de lengte van uw array. In dit geval zou je dit als volgt kunnen doen:

for (int i = 0; i <= name.length - 1; i++) {
    // ....
}

Of dit:

for (int i = 0; i < name.length; i++) {
    // ...
}