Wie Position eines Objekts in Liste herausfinden?

[zap]

Hallo,

ich bin noch relativ neu in der Programmierung, wir haben bis jetzt Processing gelernt und ich steige grade auf Eclipse um.

Ich arbeite zum ersten mal mit Listen. Im Hauptprogramm wird folgende Liste erzeugt (gekürzter Ausschnitt):

static public ArrayList<Board> boardList = new ArrayList<Board>();

Eine Methode der Board-Klasse kann weitere boards erzeugen:

public void createBoard() {
Board board = new Board(getLayer() + 1, Board.getNextLayerNumber(getLayer() + 1), nextMemory);

/** add created board to arrayList */
MainProgram.boardList.add(board);}

Nun möchte ich in der Board-Klasse an anderer Stelle mit einer Methode die Position des jeweiligen boards in boardList herausfinden. Wenn ich jedoch die indexOf()-Methode von Java benutzen möchte, muss ich in die Klammer das Objekt angeben. Allerdings heißen ja alle Boards gleich (und zwar "board"), sie unterscheiden sich lediglich in 2 verschiedenen Variablen ("layer" und "number"), wodurch jedes board individuelle Koordinaten hat. Wie kann man die Position nun herausfinden?

Allgemein fällt es mir recht schwer, mit den Listen gezielt bestimmte Objekte anzusprechen, was bei Arrays mit Formulierungen wie "beispiel[4] = ..." ziemlich einfach ging. Oder mache ich etwas falsch?

Hier noch mein Versuch, die Position in der Liste herauszubekommen. Leider kommt dabei immer 0 heraus:

public int getListPosition() {

		int id = 0;

		// for (int i = 0; i < MainProgram.boardList.size(); ++i) {
		for (Board b : MainProgram.boardList) {
			if (b.getLayer() == this.getLayer()
					&& b.getNumber() == this.getNumber()) {
				id = MainProgram.boardList.indexOf(b);
				break;
				// }
			}
		}

		return id;
	}

 

[Tarrew]

Hey, ich glaube du machst es dir ein bisschen zu kompliziert
indexOf erwartet ein Objekt. Aber du rufst die Methode getListPosition ja immer von dem zu-suchendem Objekt auf. Und ein Objekt kennt sich immer selbst. Also kannste du einfach die Referenz auf das eigene Objekt übergeben.

Also:

MainProgram.boardList.indexOf(this);

Kleines Beispiel:

public class Test {
	
	static ArrayList<Test> array= new ArrayList<Test>();
	
	public static void main(String[] args) {
		for(int i = 0; i<10; i++){
			
			Test test = new Test();
			Test.array.add(test);
		}
		Test test = new Test();
		Test.array.add(test);
		System.out.println(test.getPosition());
	}
	
	public int getPosition(){
		
		
		return Test.array.indexOf(this);
	}
}

Vllt habe ich dein Problem auch falsch verstanden

 

[Saheeda]

Du kannst auch über die Liste iterieren den Index (bzw. gleich das Objekt) zurückgeben, wenn eine Übereinstimmung gefunden wurde:

public int findPositionByName(String name){

for(int i = 0; i< boards.length; i++){
if(boards.get(i).name.equals(name){
return i;
}
}

return -1;
}

 

[zap]

@ Tarrew:
Ups, auf die Idee, mit this zu arbeiten, hätte ich auch selber kommen müssen Danke für den Hinweis. Ich verstehe allerdings nicht, warum es immer noch nicht klappt, die Konsole wirft immer -1 aus:

public int getListPosition() {
		int id = 0;
		id = MainProgram.boardList.indexOf(this);
		System.out.println("test: " + id);
		return id;
	}

Im Gegensatz zu deinem Beispielprogramm wird die Liste bei mir aber in einer anderen Klasse namens "MainProgram" erzeugt (dort allerdings nicht im Hauptprogramm, um genau zu sein). Ich weiß nicht, ob das die Ursache sein könnte.


@Saheeda:
Das ist eine gute Idee, und den Equals-Befehl kannte ich vorher noch garnicht. Leider heißen alle Boards gleich (da sie ja über die createBoard-Methode erzeugt werden), deshalb kann ich den Namen nicht zum Suchen verwenden. Momentan tun sie sich nur durch die Variablen "layer" und "number" unterscheiden, jedes board hat eine individuelle Zusammenstellung von den beiden.

 

[Saheeda]

Wie ist ein Layer aufgebaut? Was ist das? Bei Objekten ist es klar, dass der Vergleich mit "==" fehl schlägt. Bei Objekten vergleichst du so nur, ob dieselbe Speicheradresse referenziert wird, aber nicht, ob die Inhalte der Objekte gleich sind.
Welchen Datentyp haben Numbers?

"Equals" brauchst du eigentlich nur, wenn du Strings vergleichen möchtest.

 

[Tarrew]

Kannst du mal ein bisschen mehr von deinem Quellcode posten? -1 deutet ja darauf hin, dass das Objekt nicht in der Liste ist, was ja durchaus möglich ist. Vllt haste irgendeinen Denkfehler in deinem Code.
Also kompletter Code wäre ganz gut

 

[zap]

Alles klar, vielen Dank für eure Hilfe
Der untere Teil des MainPrograms ist reines Testing.

import java.util.ArrayList;
import java.util.Scanner;

public class MainProgram {

	// ATTRIBUTES-----------------------------------------------------------------ATTRIBUTES-----------------------

	int[] firstMemory = new int[10];
	static public ArrayList<Board> boardList = new ArrayList<Board>();
	static public Scanner reader = new Scanner(System.in);

	// END ATTRIBUTES

	// MAINPROGRAM----------------------------------------------------------------------MAINPROGRAM--------------

	public MainProgram() {

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		MainProgram mp = new MainProgram();

		mp.setup();

	}

	// END MAINPROGRAM

	// SETUP---------------------------------------------------------------------------------SETUP---------------------------

	void setup() {

		Globals global = new Globals();

		firstMemory[0] = 0;

		Board board1 = new Board(1, 1, firstMemory);
		boardList.add(board1);

		board1.createBoard();
		board1.createBoard();
		board1.createBoard();
		
		
		
		//TESTING------------------------------------------------------------------------TESTING---------------------------------

		/**
		 * for (Board b : boardList) { if (b.getLayer() == 2 && b.getNumber() ==
		 * 1) { b.createBoard(); break; } }
		 * 
		 * for (Board b : boardList) { if (b.getLayer() == 2 && b.getNumber() ==
		 * 3) { b.createBoard(); break; } } for (Board b : boardList) { if
		 * (b.getLayer() == 3 && b.getNumber() == 1) { b.createBoard(); break; }
		 * } for (Board b : boardList) { if (b.getLayer() == 3 && b.getNumber()
		 * == 2) { b.createBoard(); break; } } for (Board b : boardList) { if
		 * (b.getLayer() == 3 && b.getNumber() == 3) { b.createBoard(); break; }
		 * }
		 */

		board1.createBoard();
		board1.createBoard();
		for (int j = 2; j < 10; j++) {
			for (int i = 0; i < 3; i++) {
				for (Board b : boardList) {
					int test = (int) (Math.random() * 3 + 1);
					if (b.getLayer() == j && b.getNumber() == test) {
						b.createBoard();
						break;
					}
				}
			}
		}

		for (Board b : boardList) {
			b.getData();
		}

		// Board.arrayPrint();
		// System.out.println(board1.getListPosition());

		/**
		 * board1.createBoard(2, 1); board1.createBoard(2, 2);
		 * board1.createBoard(2, 3);
		 */

		/**
		 * boardList.add(new Board()); for (int i = 0; i < (int) (Math.random()
		 * * 50 + 20); i++) { Board board = new Board(); boardList.add(board);
		 * System.out.println("Anzahl der Tafeln: " + boardList.size()); }
		 * System.out.println("Größe der Liste: " + boardList.size());
		 * boardList.add(new Board());
		 * System.out.println("Neue Größe der Liste: " + boardList.size()); }
		 */

	}
	// END SETUP
}

import java.util.Arrays;

public class Board {

	// ATTRIBUTES----------------------------------------------------------------------------------ATTRIBUTES-----------------------

	/** this layer */
	private int layer;
	/** number in layer */
	private int number;
	/** id */
	private int id;
	/** is this board the active one? */
	private boolean state = false;

	/** memory-array of previous boards */
	int[] memory = new int[10];
	/** array to copy the first for the create()-method */
	int[] nextMemory = new int[10];

	// END ATTRIBUTES

	// CONSTRUCTOR------------------------------------------------------------------------------CONSTRUCTOR-----------------

	public Board(int _layer, int _number, int[] _array) {

		setLayer(_layer);
		setNumber(_number);
		memory = _array;
		id = getListPosition();
	}

	// END CONSTRUCTOR

	// IMPORTANTMETHODS--------------------------------------------------------------------------IMPORTANTMETHODS----------

	public void createBoard() {
		/**
		 * copy this memory into nextMemory to give it to the constructor of the
		 * created board
		 */
		System.arraycopy(memory, 0, nextMemory, 0, memory.length);

		/**
		 * created Board is from the next layer and gets the next biggest number of the layer
		 */
		Board board = new Board(getLayer() + 1,
				Board.getNextLayerNumber(getLayer() + 1), nextMemory);

		/** save memory of this layer */
		board.memory[board.getLayer() - 2] = getNumber();

		/** add created board to arrayList */
		MainProgram.boardList.add(board);
	}

	public void deleteBoard() {

	}

	static public int getNextLayerNumber(int _layer) {
		int count = 0;
		/** run through boardList */
		for (Board b : MainProgram.boardList) {
			/** check the boards from the wanted layer */
			if (b.getLayer() == _layer) {
				int n = b.getNumber();
				/** find the biggest number in layer */
				if (n > count) {
					count = n;
				}
			}
		}
		return (count + 1);
	}

	// END IMPORTANT METHODS

	// TESTMETHODS----------------------------------------------------------------TESTMETHODS----------------

	static public void arrayPrint() {
		for (Board b : MainProgram.boardList) {
			System.out.println("Layer: " + b.getLayer() + ", Number: "
					+ b.getNumber());
		}
	}

	public void getData() {
		System.out.println("Layer " + this.layer + ", Nummer " + this.number
				+ ", ID: " + id + ", Memory: " + Arrays.toString(memory));

	}

	// END TEST METHODS

	// ACCESS-METHODS------------------------------------------------------------------ACCESS-METOHDS-------

	public boolean getState() {
		return this.state;
	}

	public void enable() {
		if(this.state == false){
			this.state = true;
		}
		else
		{
			this.state = false;
		}			
	}
	
	public int getLayer() {
		return this.layer;
	}

	public void setLayer(int _layer) {
		this.layer = _layer;
	}

	public int getNumber() {
		return this.number;
	}

	public int getNumber(Board b) {
		return b.number;
	}

	public void setNumber(int _number) {
		this.number = _number;
	}

	public int getId() {
		return this.id;
	}

	public void setId(int _id) {
		this.id = _id;
	}


	 public int getListPosition() { int id = 0; id =
	  MainProgram.boardList.indexOf(this); System.out.println("test: " + id);
	  return id; }
	 
/**
	public int getListPosition() {
		for (int i = 0; i < MainProgram.boardList.size(); i++) {
			if (MainProgram.boardList.get(i).equals(this.getLayer())) {
				return i;
			}
		}
		return -1;
	}
	*/
}

 

[Tarrew]

Ich denke der Fehler liegt hier:
In deiner createBoard Methode erzeugst du ein neues Board und fügst es dann in die Liste ein:

public void createBoard() {
		/**
		 * copy this memory into nextMemory to give it to the constructor of the
		 * created board
		 */
		System.arraycopy(memory, 0, nextMemory, 0, memory.length);
 
		/**
		 * created Board is from the next layer and gets the next biggest number of the layer
		 */
		Board board = new Board(getLayer() + 1,
				Board.getNextLayerNumber(getLayer() + 1), nextMemory);
 
		/** save memory of this layer */
		board.memory[board.getLayer() - 2] = getNumber();
 
		/** add created board to arrayList */
		MainProgram.boardList.add(board);
	}

In Zeile 10/11 wird also ein neues Board erstellt mit folgendem Konstruktor:

public Board(int _layer, int _number, int[] _array) {
 
		setLayer(_layer);
		setNumber(_number);
		memory = _array;
		id = getListPosition();
	}

Du versuchst also beim Erstellen des Objekts die ID zu setzen, mit id = getListPosition().
Zu dem Zeitpunkt ist das Element aber noch garnicht in der Liste. Das Element wird ja erst nach dem Erzeugen in die Liste gespeichert (Zeile 18).

Deswegen wird die id immer -1 eins gesetzt. Wenn du ein Objekt erzeugst ist es klar, dass es noch nicht in der Liste sein kann. Deswegen liefert die getListPosition() auch eine -1.

 

[zap]

Klasse, daran lags! Die ID ist aus dem Konstruktor raus und wird jetzt immer in der create-methode nach dem Hinzufügen in die Liste gesetzt.

Vielen Dank an euch beide

 

[zap]

Hallo,

ich bin bei dem Programm auf ein neues Problem gestoßen. Ich poste es hier hinein, weil hier auch schon der restliche Code steht.

In dem Programm gibt es verschiedene Tafeln, die jeweils wieder andere Tafeln erzeugen können. Dadurch entsteht ein Baumdiagramm (ähnlich der Ordnerstruktur in Windows). Die Layer gibt an, auf welcher Ebene die Tafel sich im Baumdiagramm befindet, und die Nummer sagt, die wievielte Tafel es auf der Ebene ist. Ein Array dient als Erinnerung aller vorhergehender Tafeln.

Nun habe ich eine Methode geschrieben, mit der man eine Tafel löschen soll. Dies funktioniert auch. Allerdings sollen dabei auch alle Tafeln gelöscht werden, die aus ihr entstammen, d.h. die sich an die zu löschende Tafel "erinnern". Das funktioniert leider noch nicht so ganz.

Der Code funktioniert nur mit den break-Befehlen, ich verstehe aber nicht, warum. Momentan löscht er 2 Tafeln, und zwar die zu löschende und erste, die sich an diese erinnert. Um alle sich erinnernden zu löschen, müsste ich den ersten break-Befehl rausnehmen (der die for-schleife momentan vorzeitig beendet). Dann kommt allerdings folgende fehlermeldung, wenn ich das Programm starte:

"xception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
at java.util.ArrayList$Itr.next(Unknown Source)
at Board.deleteBoard(Board.java:137)
at MainProgram.setup(MainProgram.java:116)
at MainProgram.main(MainProgram.java:27)
"

static public void deleteBoard ( int _id )
	{

		for (Board b : MainProgram.boardList)
		{

			/** find board with the wanted id */
			if (MainProgram.boardList.get (_id) == b)
			{

				/**
				 * delete all boards which result from the board which
				 * should be deleted
				 */
				for (Board t : MainProgram.boardList)
				{
					if (t.memory[b.getLayer ( ) - 1] == b
							.getNumber ( )) //if any other board remembers the board  //which should be deleted
					{
						System.out.println ("delete test");
				//		t = null;
						MainProgram.boardList.remove (t
								.getListPosition ( )); //remove boards which remember the deleted board
						break;

					}
					
				}


				/** delete object and remove list entry */
				b = null;
				MainProgram.boardList.remove (_id);


				/**
				 * update all IDs (because the positions in boardList
				 * have changed)
				 */
				for (Board z : MainProgram.boardList)
				{
					z.setId (z.getListPosition ( ));
				}
				break;
			}
		}

	}

 

[Tarrew]

Ich hätte eher mit einer NullPointerException gerechnet. Du setzt t=null und versucht dann es zu removen. getListPosition() müsste eig. einen Nullpointer liefern.

Mach das t=null mal weg und remove das Element so aus der Liste. Du wirst nach dem for-Schleifen-Durchgang warsch. garkeine Referenz mehr auf das Board haben und der Garbage Collector sollte das dann automatisch "abräumen".

 

[zap]

Hab den Fehler gefunden. Die foreach-Schleife sagt, es soll jedes Objekt von boardList überprüft werden. Die Größe von boardList wird aber in der Schleife selber geändert, da Objekte gelöscht werden. Wenn die Schleife mehr als einen Durchlauf hat (also kein break-Befehl auftaucht), gibt es deshalb die Fehlermeldung.

Ich hab es mit einer zusätzlichen for-Schleife gelöst, die runterzählt und dadurch die äußerste Layer zuerst prüft. Da pro Layer nur eine Tafel auf dem Pfad der zu Löschenden liegen kann, kann ich das break dann stehen lassen.

static public void deleteBoard ( int _id )
	{

		for (Board b : MainProgram.boardList)
		{

			/** find board with the wanted id */
			if (MainProgram.boardList.get (_id) == b)
			{

				/**
				 * delete all boards which result from the board which
				 * should be deleted
				 */

				for (int i = Globals.boardMax ; i > b.getLayer ( ) - 1 ; i -- ) //start with the biggest layer, because the positions are effected by deleting objects from the list
				{
					for (Board t : MainProgram.boardList)
					{

						if (t.memory[b.getLayer ( ) - 1] == b
								.getNumber ( )) //checks if t remembers b
						{
							//		t = null;
							MainProgram.boardList.remove (t
									.getListPosition ( ));
							break;

						}
					}

				}


				/** delete object and remove list entry */
				b = null;
				MainProgram.boardList.remove (_id);


				/**
				 * update all IDs (because the positions in boardList
				 * have changed)
				 */
				for (Board z : MainProgram.boardList)
				{
					z.setId (z.getListPosition ( ));
				}
				break;
			}
		}

	}

Was ich mich frage, ist ob es nicht allgemein bequemere Wege gibt, einzelne Objekte in einer Liste anzusprechen? Bis jetzt mach ich das nur mit for-each Schleifen verbunden mit if-Abfragen. Den vorschlag von Saheeda kann ich leider nicht anwenden, da meine Objekte alle gleich heißen (oder gibt es eine Möglichkeit, Objektnamen automatisch z.B. hochzählen zu lassen, ohne Arrays zu verwenden?).

 

[zap]

@ Tarrew:
Ja, das t= null hat auch Probleme verursacht, das war in dem code deshalb ausgeklammert. Ich hatte vergessen zu fragen, warum das nicht klappt. Dann kann ich das jetzt ja ganz rausnehmen

 

[Harry Kane]

Ich bin gerade ziemlich verwirrt.
Meines Erachtens ist diese deine Kombination aus for each Schleife und if:

public Board findBoard(List<Board> boards, int index){
    for(Board b: boards){
        if(boards.get(index) == b){
            return b;
        }
    }
    return null;
}

nur ein stark verkomplizierte Version von:

public Board findBoard(List<Board> boards, int index){
    return boards.get(index);
}

 

[Joose]

Was ich mich frage, ist ob es nicht allgemein bequemere Wege gibt, einzelne Objekte in einer Liste anzusprechen?

Wenn du den Index des Elements nichts weißt gibt es keinen "bequemeren" Weg.

........., da meine Objekte alle gleich heißen (oder gibt es eine Möglichkeit, Objektnamen automatisch z.B. hochzählen zu lassen, ohne Arrays zu verwenden?).

Achtung: Du verwechselst hier glaub ich etwas (auf jeden Fall liest es sich so). Der Variablennamen im Code hat nichts mit dem Objekt zu tun, sondern dient lediglich den Code lesbar zu machen.
Objekte haben keine "Namen", aber es gibt Variablen/Attribute mit "Namen" die auf ein Objekt verweisen können. Doch diese Variablen/Attribute kann man nicht dynamisch anlegen.

Wenn du etwas "ähnliches" realisieren willst wirst du mit Maps arbeiten müssen

 

[zap]

Danke für die Hilfe an alle, das Programm ist fertig geworden und funktioniert gut