ArrayIndexOutOfBoundsException, ich finde den Fehler nicht?

berndoa

Top Contributor
Hallo,
ich habe folgende Methode die dutzende Male aufgerufen wird:

Java:
    public static boolean increasing(long[] array,long max){
        //beispiel: array={0,1,2}, array.length=3, index=3, max=6
        int index=array.length-1;
        //6-3+1 +index=4+index ={4,5,6}
        while((array[index]==(max-array.length+1+index))&&(index>=0)){
            index--;
        }
        if(index<0){return false;}
        
        array[index]++;
        
        for (int i=1;index+i<array.length;i++){
            array[index+i]=array[index]+i;
        }
        
        return true;
    }

Compilieren klappt aber beim Ausführen des Programms sagt er mir dass die methode von ner anderen Stelle im Programm aufgerufen wird und in der Zeile mit dem while eine
java.lang.ArrayIndexOutOfBoundsException: -1
produziert.

Ich kapiere einfach nciht wie es der Index da überhaupt schafft, aus den Grenzen des zulässigen rauszukommen.
Ich meine, anfangs wird er ja auf den maximalen indexwert, nämlich arraylänge-1 gesetzt und danach so lange verringert bis entweder die eine bedingung nciht mehr erfüllt wird oder eben der index <0 ist.

heißt, mal von der bedingugn abgesehen ist im worst case am ende der index =0, while shcleife wird ein letztes mal aufgerufen, index---, nun also index=-1, while schleife wird nicht mehr augerufen weil index nicht >=0, fertig.

wie kann der index da ausserhalb der zulässigen bereiche liegen? 😵

wo ist mein fehler da?
 
Die Bedingungen der while-Schleife werden - wie immer - von links nach rechts ausgewertet. Wenn Du also im Fall von index == 0 noch eine Wiederholung hast, wird der index = -1. Anschließend wird die Bedingung erneut überprüft: array[index]==(max-array.length+1+index) -> array[-1] == (max-....)
 
Wenn der Index 0 ist wird es nochmals aufgerufen. Dann ist er - 1 und beim ersten check im while gibts einen Fehler. Was soll der Code eigtl tun? Das geht bestimmt lesbarer
 
Der versucht ernsthaft array[-1] aufrzurufen obwohl schon index>=0 nicht erfüllt ist und demnahc die und bedingung gar nicht erfüllt werden kann?

pff -.-

dann müsste doch, wenn ich die bedingungen tausche (also das index>=0 links steht, das klappen, oder?


was das teil tut, ist etwas schwer zu erklären.

aber ich versuchs trotzdem mal:

es wird zwar ein long array gegeben, aber das muss man sich fast wie eine array.length-stellige zahl vorstellen.
wie so hexadezimalzahl oder so.

konkret wird bspw. das array {1,2,3,4} übergeben.
mit max=5 wird dann die nächste "zahl" {1,2,3,5} generiert.
werfe ich array={1,2,3,5} und max=5 rein, dann wird als nächste "zahl"
{1,2,4,5} produziert.

usw.

das ist etwas sehr grob gesagt wie das hochzählen bei einer mehrstelligen zahl,
nur dass sichergestellt ist dass die ziffern definitiv aufsteigend sind von links nahc rechts und die rechteste ziffer maximal gleich dem input max ist.

ist ganz entfernt sowas wie die nachfolgerfunktion bei natürlichen zahlen, nur dass es hier halt mehre zahlen in nem array sind.


benutze das unter anderem um zum beispiel alle einzigartigen kombinationen von 4 zahlen aus dem zahlenbereich 0-7 systematisch durchzugehen.
fange mit 0,1,2,3 an und gehe der reihe nahc hoch bis 4,5,6,7.

heißt ich setze mein array der länge 4 anfangs gleich 0,1,2,3 und zähle dann durch aufrufen der funktion immer "um eins hoch" solange das eben geht.
ob nochmal erfolgreich erhöht wurde und werden konnte, gibt ja die funktion per bol wert zurück.



wie das eigentliche hochzählen geht:
gehe mit dem zeiger zum letztn element des arrays.
gehe so lange einen platz im index zurück bis ein element gefunden wurde das nicht "maximal" ist .
was maximal ist, wird eben, abhängig auch von der position, durhc die bedingung gegeben.

wird auf gut deutsche keine nicht-maximale position geufnden, ist der index zuletzt auf -1 und es wird false zurückgegeben. konnte also nicht erhöht werden.

falls was nichtmaximales gefunden wurde, wird die stelle um 1 erhöht und die zahlen recht davon immer um 1 mehr als die zahle davor gesetzt. also 4,5,6,7 und sowas.


habe es nur so gelöst weil ich bspw. für eine situation wo ich alle 6 stelligen zahlen (a,b,c,d,e,f) aus dem bereich 1-49 finjden will, die aufsteigend sind, eben 49^6 zahlenkombinationen generieren mpsste und für jede a<b<c<d<e<f prüfen müsste.
wäre mein array nich länger, würden noch mehr dazu kommen, bspw. 49^8.

ganz davon ab dass ich da nicht unabhängig von der arraylänge bin.
also für 6stelliges array 6 vershcachtelte for schleifen bräuchte und so.

und so ist meine variante unabhängig von der array länge, da ich alle werte durchgehe indem ich das array anfangs auf den kleisnten wert setze und immer um eins erhöhe solange es eben geht.
 
wow ich habe es geschafft einen outofmemoryerror: java heap space zu schaffen! :O

meine Programme sind scheinbar echt viel zu ineffizient :-/
 
wow ich habe es geschafft einen outofmemoryerror: java heap space zu schaffen! :O
Kann es sein, dass du den Rückgabewert von increasing() nicht auswertest und es deshalb nicht merkst, wenn du fertig bist? Das würde beides erklären (IndexOutOfBounds in der ersten Version, Endlosschleife mit OutOfMemory in der zweiten Version).

So würde es funktionieren:
Java:
public static void main(String[] args) {
    long[] array = { 0, 0, 0, 0 };
    while (increasing(array, 4)) {
        System.out.println(Arrays.toString(array));
    }
}
 
Java:
public boolean increase(int[] zahlen, int max) {
    return increase(zahlen, zahlen.length-1, max);
}

private boolean increase(int[] zahlen, int pos, int max) {
    if (pos < 0) {
        return false;
    }

    if (zahlen[pos] < max) {
        zahlen[pos]++;
    } else {
        if (!increase(zahlen, pos-1, max-1)) {
            return false;
        }
        zahlen[pos] = zahlen[pos-1] + 1;
    }
    return true;
}

Dann liefert
Java:
int[] arr = {1,2,3};
do { System.out.println(java.util.Arrays.toString(arr));} while (increase(arr, 6));

als Ausgabe:
Code:
[1, 2, 3]
[1, 2, 4]
[1, 2, 5]
[1, 2, 6]
[1, 3, 4]
[1, 3, 5]
[1, 3, 6]
[1, 4, 5]
[1, 4, 6]
[1, 5, 6]
[2, 3, 4]
[2, 3, 5]
[2, 3, 6]
[2, 4, 5]
[2, 4, 6]
[2, 5, 6]
[3, 4, 5]
[3, 4, 6]
[3, 5, 6]
[4, 5, 6]

Nachtrag: @berndoa, Deine iterative Lösung ist natürlich effizienter.
 
Zuletzt bearbeitet:
Kann es sein, dass du den Rückgabewert von increasing() nicht auswertest und es deshalb nicht merkst, wenn du fertig bist? Das würde beides erklären (IndexOutOfBounds in der ersten Version, Endlosschleife mit OutOfMemory in der zweiten Version).
Hallo, ne, das mit dem indexoutofbounds lag tatsächlich dran dass es -1 wird und so.


habe auch einen fehler gefunden in einer methode wo ich die anzahl an gleichen elementen in 2 arraylists finden will.
da laufe ich mit 2 indizes indexa und indexb durch.

hatt ne while schleife die eben so lange ausgeführt wird wie beide indizes < der länge des jeweiligen arrays sind.
tja und innendrin hatte ich 3 if bedingungen. die die 3 fälle abdeckten wenn das elemente im ersten array <,= oder > dem im 2. array ist. und dementsprechend mein zähler und oder einer oder beide der indizes erhöht wird.

idee auch richtig, nur hatte ich ein wenig nicht bedacht dass gegebenenfalls pro while durchgang mehrere der if bedingungen abgearbeitet werden könnten.
weil ich die nicht wirklich mit mit if[}else if[} und so voneinander abgetrennt ahtte, sondern einfahc 3 if bedingungen nacheinander stehen hatte -.-

also in schönes if else gebilde geändert und es läuft.

das memoryoutofbounds lag wohl zum teil an dem fehlerbedingten unberechenbaren verhalten hier, sowie wohl auch shclicht daran, dass ich einfach zu viel speicher verbrauche.
 

Neue Themen


Zurück
Oben