Array befüllen ohne immer den Index anzugeben

[!lkay]

Hallo.

Habe hier einen Code, der in der Zeile

blt[blt.length] = new Verein(a, b, c , d);

fehlschlägt.

Vorhaben: Dem Array ohne immer den Index mitzugeben , ein neues Element hinzufügen. Es muss bei einem Array bleiben, darf keine List nehmen.

Fehler: java.lang.ArrayIndexOutOfBoundsException.

public class VereinsManager

{

private Verein[] blt = new Verein[18];



{

  ad("BvB" , 12, 19, 44);



for(Verein d : blt)

{

    System.out.println(d.getName() + "   " + d.getGames() + "    " + d.getRank() + "    " + d.getPoints());

}



    

}

  

public VereinsManager(){}



public void ad(String a, int b, int c, int d) 

{

    blt[blt.length] = new Verein(a, b, c , d);

}

Kann mir jemand sagen, warum das fehlschlägt?

[DMW007]

Weil der Index 0-Basierend ist. Element 1 hat den Index 0, und das letzte Element 18 somit den Index 17. Da dein Array eine Länge von 18 hat, greifst du mit Index 18 auf das 19. Element zu, welches es nicht gibt. Daher die Exception. Wenn du variabel auf das letzte Element zugreifen willst, musst du von der Länge des Arrays eins subtrahieren. Möchtest du generell Elemente hinzufügen ohne jedes mal den Index angeben zu müssen, verwende einen Zähler oder direkt einen dynamischen Array.
Damit könntest du dann so etwas machen:

ArrayList<Verein> vereine = new ArrayList<Verein>();

vereine.add(new Verein(a,b,c,d));

Und für Java haben wir einen eigenen BBCode (java statt code, wird im erweiterten Editor auch oben angezeigt), mit entsprechend passendem Syntaxhighlighting für Java, bitte zukünftig diesen nutzen. Habs ediert.

[Nuebel]

Wie mein Vorposter bereits richtig erwähnte, fangen Indices bei 0 an. Der Index für das letzte Element im Array lautet also array.length - 1.
Da du keine Listen verwenden darfst, kannst du dir eine Hilfsmethode oder -klasse schreiben, wenn dir die Angabe von Indices so nervt.

Eine kleine Klasse DynamicArray könnte so aussehen:

import java.lang.reflect.Array;



public class DynamicArray<T> {



	public static void main(String[] args) {

		DynamicArray<Integer> da = new DynamicArray<>(Integer.class, 5);

		for (int i = 0; i < 5; ++i) {

			da.add(i*i);

			System.out.println("Element at index " + i + ": " + da.get(i));

		}

		// Eigentlich ungültigen Index 5 testen:

		da.add(100);

		System.out.println("Element at index 5:" + da.get(5));

	}



	// ---------------------------------------------------------------------



	private T[] array;

	private Class<T> clazz;

	private int capacity;

	private int currentIndex;



	public DynamicArray(Class<T> clazz, int capacity) {

		this.clazz = clazz;

		array = (T[]) Array.newInstance(clazz, capacity);

		this.capacity = capacity;

		currentIndex = 0;

	}



	public final void add(T element) {

		checkNewCapacityIsNeeded();

		array[currentIndex] = element;

		++currentIndex;

	}



	public final T get(int i) {

		if (i < 0 || i >= capacity)

			throw new IllegalArgumentException("invalid index: " + i);



		return array[i];

	}



	private final void checkNewCapacityIsNeeded() {

		if (currentIndex == capacity) {

			T[] newArray = (T[]) Array.newInstance(clazz, ++capacity);

			for (int i = 0; i < capacity-1; ++i) {

				newArray[i] = array[i];

			}

			array = (T[]) newArray.clone();

		}

	}

}

Für deinen kleinen Fall dürfte eine Hilfsmethode allerdings ausreichen. Speicher dazu den aktuellen Index und inkrementiere denselbige, wenn ein Element hinzugefügt wird. Vergiss aber nicht zu überprüfen, ob der Index gültig ist.

[Essah]

Wenn du den Index nicht immer angeben willst würde doch eigentlich etwas in dieser Art schon reichen:

Verein[] Vereine = new Verein[18];

int ArrayPosition = 0;



public void Hinzufuegen(Verein derVerein){

     Vereine[ArrayPosition] = derVerein;

     ArrayPosition++;

}