wie kann ich in zweidimensionaller Arraylist auf die einzelnen Elemente zugreifen ?

[Vilkazzz]

in meinem nächsten Test brauche ich zwei dimensionale arrays um Text zu speichern,
so in etwa würde ich es mit arrays machen.

Beispiel text

Spoiler

Ruffytxt
1
Hallo, ich heiße Ruffy und ich bin der König der Piraten !
Ich will mit meiner Crew ins Meer stechen, nur hab ich ein Problem..
Buggy der Clown hat durch ein fieses Zauber mein Gedächniss
über wochentage, Monate und Jahreszeigen gelöscht !
hillft du mir dieses Wissen wieder zu erlernen ?

Buggytxt
1
Ha Ha !
Du wirst es Niemals schaffen !

Ruffytxt
2
und ob ! zusammen mit
werden wir es schaffen !

Buggytxt
2
Wenn du schon so sicher bist,
hast du sicherlich nicht gegen einen
klitzekleinen gemeinen RIESENTEST !
Wenn du verlierst, wirst du mir
die nächsten 5 Jahre dienen !

Ruffytxt
3
einverstanden,
aber wenn ich gewinne,
kriege ich an der Stelle mein Gedächniss wieder

Buggytext
ha ha ! das schaffst du nie !
abgemacht Strohhut !

So in etwa stehts in der Textdatei geschrieben, die Erkennung funktioniert auch einwandfrei.
Codeausschnitt falls wem interessiert..

Spoiler

while (sc.hasNextLine()) {
			String line = sc.nextLine();
			if (line.startsWith("Ruffytxt")) { // die ansprechzeile im text
												// wurde gefunden
				// System.out.println(line+" gefunden");
				int dnr = sc.nextInt();
				int zeilenCounter = 0; // wird gezählt wieviele Zeilen bis ""
										// kommen.
				System.out.println("Ruffy Text nr " + dnr); // ausgabe von der
															// Zahl hinter
															// "ruffytxt"
				sc.nextLine();// line sprung um zum text zu kommen
				while (sc.hasNextLine()) { // es wird geguckt ob es überhaupt
											// nächste line gibts
					String dline = sc.nextLine(); // die nächste line im
													// charakter dialog wird
													// gelesen
					if (dline.equals("")) {
						break; // am ende jedes Dialoges ist eine leerzeile,
								// dies symbolisiert das ende eines text
								// abschnittes.

					}
					System.out.println(dline); // es ist diese line

					zeilenCounter++;
					arralistIntern.add(dline);
				}
				arrayGlobal.add(arralistIntern);
				System.out.println("Dialog Ruffy Ende! es hatte "
						+ zeilenCounter + " Zeilen");
				System.out.println();

				// System.out.println(sc.);
			}
			;

mein problem ist, ich weiss nicht im voraus wieviele Zeilen welcher Charakter sprechen wird,
sondern erst nachdem der Text des Charakters zu ende ausgelesen wird von einer text datei.

Ich hab gesucht, aber kein Befehl gefunden, der mit scaner Objekt zusammen eine Zeile nach oben geht, anstadt nach unten. also Gegenteil von nextLine();

gibt es sowas ? also scaner.pastLine() oder sowas ? denn dann lese ich einfach ein Abschnitt,
zähle die Anzahl der Zeilen, mache Rückwertsschleife miz Zuweisung,
dann vorwärts Schleife um die Zeilenanzahl, und gucke weiter im text nach nächsten Schlüsselwörtern.

so muss ich entweder überdimensionierte arrays für alle Fälle machen, wobei die Hälfte dann undefiniert sein wird (will ich nicht, riecht nach Verschwendung)

oder z.B. mit zweidimensionalen Arraylists arbeiten ?

inzwischen hab ich es geschafft (google sei dank ) die zuzuweisung ohne Fehlermeldung hinzuschreiben, aber so richtig funktioniert es nicht ....

hier grob vereinfachter code.

List<String> arralistIntern = new ArrayList<String>();
List<List<String>> arrayGlobal = new ArrayList<List<String>>();
...
...Auslese und Zuweisungsverfahren
...
...arralistIntern.add(dline);//interne Schleife
...				}
arrayGlobal.add(arralistIntern);//externe Schleife

nur funktioniert es gar nicht wie ich es will.

wenn ich am ende den folgenden code hinschreibe um zu gucken
wie lange welche Liste überhaupt ist.

System.out.println("WIDERGABE TEST ! ! ! ");
		int globalX = arrayGlobal.size();
		System.out.println(globalX);
		for (int i = 1; i <= globalX; i++) {
			int localx = arralistIntern.size();
			for (int b = 1; b <= localx; b++) {
				System.out.println("G:" + i + " I:" + b);
			}

		}

nun. ich habe dann 5 Globale Dialoge (Richtig)
aber nicht 5 interne listen, sondern nur eine und die selbe.
was ich im grunde auch so hingeschrieben habe...

ich hab also nicht zweidimensionale arrayliste, sondern zwei eindimensionale geschafft ?

wärend ich es hire tippe, kam ich auf folgende idee,

beim gefundenem Schlüsselword wird eine temporaire liste erstellt,
wo solange text hinzugefügt wird, bis leerzeile kommt (schlüsselsymbol für abschnitt ende)

dann deklariere ich eindimensionale array mit länge von der temporairen liste.
mache eine for schleife und weise jedem array Objekt den wert von entsprechender Liste zeile zu.

am ende addiere ich den array zu der arralist....

klingt als ob es gehen würde, aber,

im netz hab ich aber Dialoge und Beispiele zu zweidimensionallen arraslists gefunden, es wäre in meinem fall einfacher, aber gibt den sowas überhaupt wie

String zeile = globaleArraylist<3>.interneArralist<4>

ist spät, sry für wall of text.

hier der ganzer code, aber da ihr die Textdatei nicht habt, wird es bei euch ohne einer Anpassung nicht laufen. Text datei inhalt ist weiter oben unter Text Spoiler

Spoiler

package de.vilkas;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Textlesen {

	public static void main(String[] args) throws FileNotFoundException {
		File file = new File(
				"C:/java/Workspace/MonateSpiel/src/de/vilkas/txtde.txt");

		Scanner sc = new Scanner(file);
		List<String> arralistIntern = new ArrayList<String>();
		List<List<String>> arrayGlobal = new ArrayList<List<String>>();

		while (sc.hasNextLine()) {
			String line = sc.nextLine();
			if (line.startsWith("Ruffytxt")) { // die ansprechzeile im text
												// wurde gefunden
				// System.out.println(line+" gefunden");
				int dnr = sc.nextInt();
				int zeilenCounter = 0; // wird gezählt wieviele Zeilen bis ""
										// kommen.
				System.out.println("Ruffy Text nr " + dnr); // ausgabe von der
															// Zahl hinter
															// "ruffytxt"
				sc.nextLine();// line sprung um zum text zu kommen
				while (sc.hasNextLine()) { // es wird geguckt ob es überhaupt
											// nächste line gibts
					String dline = sc.nextLine(); // die nächste line im
													// charakter dialog wird
													// gelesen
					if (dline.equals("")) {
						break; // am ende jedes Dialoges ist eine leerzeile,
								// dies symbolisiert das ende eines text
								// abschnittes.

					}
					System.out.println(dline); // es ist diese line

					zeilenCounter++;
					arralistIntern.add(dline);
									
				}
				arrayGlobal.add(arralistIntern);
				System.out.println("Dialog Ruffy Ende! es hatte "
						+ zeilenCounter + " Zeilen");
				System.out.println();

				// System.out.println(sc.);
			}
			;

			if (line.startsWith("Buggytxt")) { // die ansprechzeile im text
												// wurde gefunden
				// System.out.println(line+" gefunden");
				int dnr = sc.nextInt();
				System.out.println("Buggy Text nr " + dnr); // ausgabe von der
															// Zahl hinter
															// "ruffytxt"
				sc.nextLine();// line sprung um zum text zu kommen
				while (sc.hasNextLine()) { // es wird geguckt ob es überhaupt
											// nächste line gibts
					String dline = sc.nextLine(); // die nächste line im
													// charakter dialog wird
													// gelesen
					if (dline.equals("")) {
						break; // am ende jedes Dialoges ist eine leerzeile,
								// dies symbolisiert das ende eines text
								// abschnittes.

					}
					System.out.println(dline); // es ist diese line
					arralistIntern.add(dline);
				}
				arrayGlobal.add(arralistIntern);
				System.out.println("");

				// System.out.println(sc.);
			}
			;

		}
		sc.close();
		System.out.println("WIDERGABE TEST ! ! ! ");
		int globalX = arrayGlobal.size();
		System.out.println(globalX);
		for (int i = 1; i <= globalX; i++) {
			int localx = arralistIntern.size();
			for (int b = 1; b <= localx; b++) {
				System.out.println("G:" + i + " I:" + b);
			}

		}

	}

}

 

[Keyone94]

ich verstehe deine Frage leider nicht so wirklich (falls da eine Frage war? )
aber da du anscheinend dich noch nicht mit Methoden und Klassen auskennst, solltest du besser damit erstmal Anfangen, bevor du über 2D Listen nachdenkst (und ich denke du brauchst keine 2D liste für das, was du planst)

damit dir Morgen vlt etwas besser geholfen werden kann, ein paar Fragen ^^ :
1) was genau willst du überhaupt in deiner Liste abspeichern?
2) wo liegen momentan deine Probleme damit?
3) was genau hast du danach damit vor?

 

[Vilkazzz]

ich gebe mal ein Beispiel mit arrays, um zu zeigen was ich in etwa möchte

String ruffyy[0][0]="Erste Zeile aus dem Dialog 1, für ruffytxt folgt"
String ruffyy[0][1]="nächsteZeile aus dem Dialog, der ruffytxt folgt"
String ruffyy[0][2]="nächsteZeile aus dem Dialog, der ruffytxt folgt"
String ruffyy[0][3]="nächsteZeile aus dem Dialog, der ruffytxt folgt"
String ruffyy[0][4]="nächsteZeile aus dem Dialog, der ruffytxt folgt"

String ruffyy[1][0]="Erste Zeile aus dem Dialog 2, für ruffytxt folgt"
String ruffyy[1][1]="nächsteZeile aus dem Dialog, der ruffytxt folgt"
String ruffyy[1][2]="nächsteZeile aus dem Dialog, der ruffytxt folgt"

String ruffyy[2][0]="Erste Zeile aus dem Dialog 3, für ruffytxt folgt"
String ruffyy[2][1]="nächsteZeile aus dem Dialog, der ruffytxt folgt"
String ruffyy[2][2]="nächsteZeile aus dem Dialog, der ruffytxt folgt"
String ruffyy[2][3]="nächsteZeile aus dem Dialog, der ruffytxt folgt"

Ich will jede Zeile so abgespeichert haben, dass ich jede Zeile einzeln ansprechen kann.

Mein Problem ist, dass ich es mit array list machen wollte, da ich nicht genau weiss,
Wieviele Zeilen jeder Testabschnitt im voraus haben wird.

array will schon bei variablen definierung wissen wie lang es sein wird.

ich könnte einfach allen die länge von 20 geben, denn soviel wird wohl niemalls erreicht,
aber es kommt mir schlampig vor !

ich kann nicht die syntax finden für zweidimensionale arraylists,
sprich gibt es überhaupt bei Arraylists die möglichkeit alternatyv zu zweidimensionalen arrays zu machen ? so in etwa ?

String zeile = ruffyy[3][1];

mit array geht es ..

aber auch mit zweidimensionalen arraylists ?

was ich vorhabe ?

primair gehts um Übung.
Sekundair gehts darum, das ich ein Spiel für mein Sohn machen will,
wo er endlich mal spielend Wochentage sowie Monate lernen kann.

Es gibts in diesem Spiel einige Dialoge, und ich will die alle in eine Textdatei schreiben.
So .. so kann ich es jemandem geben der die Gramatik überprüfen kann, denn mein Deutsch
ist vergleichbar s******e.

Ausserdem, wenn ich es für ein Freund geben würde, der andere Sprache spricht, müsste ich nur die Textdatei übersetzen, und nicht im code nach Dialogen suchen

Diese Klasse soll also nur die text datei durchlesen, und den text entsprechend den String variabeln zuweisen, und wenn ich in einem Dialog paar Zeilen hinzufüge oder lösche, soll es kein Problem sein, denn die Textdatei wird beim jedem Program start neu geöffnet und durchgelesen.

auf die String variablen greife ich dann später im main zu, und stelle so die dialoge im hauptprogramm her.

so, die Augen fallen zu, gute nacht wer noch wach ist

 

[Keyone94]

Sekundair gehts darum, das ich ein Spiel für mein Sohn machen will,
wo er endlich mal spielend Wochentage sowie Monate lernen kann.

sol noblen ziele hört man selten und sollten stark unterstützt werden =)

ja es gibt 2D Listen und dein Ansatz hier:

List<List<String>> arrayGlobal = new ArrayList<List<String>>();

ist auch Richtig (und ich denke es ist für dein Problem passend)

aber vlt reicht es für den Anfang, wenn du einen Dialog als einzelnen String speicherst? oder wäre das unpassend?
also, dass du die einzelnen Zeilen auch wirklich mit Zeilenumbrüchen abspeicherst, z.B. so:

String s = " erste Zeile \n zweite Zeile";
System.out.println(s);

oder so:

String dialog = "";
String nextLine = "leer" //ist mit "leer" gefüllt, damit die while Schleife startet

while( (! nextLine.equals( "" )) && sc.hasNextLine() ){ //läuft solange es was zu lesen gibt und das gelesene nicht "" ist
      nextLine = sc.nextLine();  //liest die nächste Zeile des Dialogs
      dialog += nextLine + "\n"; //fügt die nächste Zeile des Dialogs inklusive Zeilenumbruch an
}

System.out.println( dialog );

achja: \n ist ein Zeilenumbruch ( hätte ich vlt erwähnen sollen ^^ )

 

[Vilkazzz]

es würde Prinzipiell gehen, aber ich mach mal paar screenshots wieso ich jede Zeile einzeln haben wollte

(sind Bildschirmscreenshots, zu groß für "Grafik einfügen")

https://www.dropbox.com/s/zbwn3lkgvrm92mo/Screenshot 2014-07-27 10.12.11.png?m=

https://www.dropbox.com/s/dtj8cly009ik8ux/Screenshot 2014-07-27 10.12.47.png

Grund 1 wäre pure Optik, mit setBounds kann ich viel einfacher jedes Dialogfenster
verschieben wie ich lustig bin, Fontgröse, Farbe usw

so müsste ich die Strings spalten usw
der zweiter Grund ist, hin und wieder kommt "spielername" im txt vor.
nun gut, ich kann einfach vor der ausgabe jeden String nach "%Spielername" durchsuchen
lassen und es dann mit dem wert der Variable ersetzen.

Ich will aber nicht "quick and Dirty" machen,
so könnte ich einfach ohne Textdatei, sondern im jedem JPanel die Strings per hand eingeben.

inzwischen hab ich auch idee wie ich es speicherlatz sparend mit arrays machen kann,
aber prinzipiell, geht mit arraylist die von mir gewünschete exakte Abfrage überhaupt?

und habe keine angst wegen komplexität, im Gegenteil ! Es freut mich wenn ich etwas neues hier erlerne !!!

Java ist eine sehr einfache, bequehme und intuitive Sprache im vergleich dazu, was ich damals gelernt hatte. Verschone mich also nicht von Sachen, wo du denkst es sei zu komplex,
im Gegenteil, ich bitte darum, erdrückt mich mit komplexität und unbegrenzten Möglichkeiten

Ich habe zu lange nicht programiert, und kann mir kein luxus mehr erlauben es slow and easy anzugehen. :/ wenn ich die Zeit ein bisschen einholen will, muss ich also vollgas geben bis mein Kopf explodiert

 

[Keyone94]

ja das geht mit 2D Listen sogar ganz gut =)

also gut dann zu 2D Listen:
bin deinen Code gerade mal am durchgehen (war gestern Abend zu müde dazu)
zuerst einmal:
du packst bei dir immer wieder Elemente in die selbe ArrayList intern, also erst bei Ruffy dann bei Buggy und diese eine Liste packst du dann doppelt in die globale

wie ich das meine:

Spoiler: Spoiler

sagen wir deine Dialoge sind
Ruffy: "Hallo" , "Welt"
Buggy: "Hi" , "Ruffy" , "wie gehts?"

du packst erst "Hallo" und "Welt" in deine interne Liste,
diese interne liste packst du dann in die externe rein, das sieht also so aus:
{ {"Hallo", "Welt"} }

danach packst du die dialoge von Buggy in die interne Liste (es ist aber noch die selbe Liste wie bei Ruffy) und wir erhalten das:
{ {"Hallo", "Welt", "Hi", "Ruffy" , "Wie gehts?"} }
deine Liste mit Ruffy Dialogen, hat also auch die von Buggy

und danach fügst du die interne Liste nochmals in die äußere rein, erhälst also das:
{ {"Hallo", "Welt", "Hi", "Ruffy" , "Wie gehts?"} , {"Hallo", "Welt", "Hi", "Ruffy" , "Wie gehts?"}}
(Die Liste mit Ruffy Dialogen) (Die Liste mit Buggy Dialogen)

Was ich sagen will: du müsstest für die Ruffy und Buggy Dialoge jeweils eine eigene interne Liste erstellen und kannst nicht für beide die selbe Liste verwenden

Spoiler: etwas Code

package de.Gorf.GorfMaker;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Textlesen {

	public Textlesen() throws FileNotFoundException {
		File file = new File(
				"C:/java/Workspace/MonateSpiel/src/de/vilkas/txtde.txt");

		Scanner sc = new Scanner(file);
		List<List<String>> arrayGlobal = new ArrayList<List<String>>();

		while (sc.hasNextLine()) {
			String line = sc.nextLine();
			if (line.startsWith("Ruffytxt")) {

				int dnr = sc.nextInt();
				System.out.println("Ruffy Text nr " + dnr);

				sc.nextLine();

				// Den Dialog als Liste einlesen
				List<String> listIntern = readDialog(sc);
				// Die Liste mit dem Dialog in die globale Liste einfügen
				arrayGlobal.add(listIntern);

				System.out.println("Dialog Buggy Ende! es hatte "
						+ listIntern.size() + " Zeilen");
				System.out.println();

			}

			if (line.startsWith("Buggytxt")) {

				int dnr = sc.nextInt();
				System.out.println("Buggy Text nr " + dnr);

				sc.nextLine();

				// Den Dialog als Liste einlesen
				List<String> listIntern = readDialog(sc);
				arrayGlobal.add(listIntern);

			}

		}

		sc.close();

		System.out.println("WIDERGABE TEST ! ! ! ");

		for (int i = 0; i < arrayGlobal.size(); i++) {
			// die i-te Liste von der globalen geben Lassen (den i-ten Dialog)
			List<String> lokal = arrayGlobal.get(i);

			// alle Zeilen der lokal Liste (dieses Dialoges) durchgehen und
			// ausgeben
			for (int u = 0; u < lokal.size(); u++) {
				System.out.println(lokal.get(u));
			}

		}

	}

	/**
	 * Read Dialog liest den Scanner bis zu nächsten leeren Zeile aus, und gibt
	 * das ausgelesene in einer Liste mit Strings wieder
	 */
	private List<String> readDialog(Scanner sc) {
		List<String> arraylistIntern = new ArrayList<>();
		while (sc.hasNextLine()) {
			String dline = sc.nextLine();
			if (dline.equals("")) {
				break;
			}
			System.out.println(dline); // es ist diese line

			arraylistIntern.add(dline);
		}
		return arraylistIntern;
	}

	/** Die main (schön kurz und knapp gehalten) */
	public static void main(String[] args) throws FileNotFoundException {
		new Textlesen();
	}

}

ich hab deinen Code mal in Methoden verpackt und leicht abgeändert, ich hab leider nicht so viel Zeit gerade, aber vlt kannst du es dir mal anschauen und e hilft dir weiter =)
ansonsten einfach nochmal nachfragen ^^

 

[Vilkazzz]

aaaach, sehr nice,
der Befehl arrayList.get(i); war das Werkzeug welches ich gesucht hatte !

auch den code schön aufgeräumt

danke ! dann gehe ich mal mit dm arrayList.get(i) rumzuspielen

und ja, ich hatte wirklich alles einfach zu einer liste eingefügt, aber jetzt kann ich mit get und sysout
meine code testen.

p.s. was wird als profesioneller angesehen, public class'es im selber Editor Fenster reinzuschreiben
wo die main ist, oder möglichst doch für jede Class einen eigenen Fenster machen ?

intuitiv würde ich so machen, dass ich die Klassen die ich zu 100% nur in der einer main gebrauchen würde,
in der main auch lassen würde, aber wenn ich die in min. 2 Klassen gebrauchen kann,
dann würde ich ihr "eigenes Fenster" also "New>Class" schenken.

Oder gibt es da keine ungeschriebene Regeln ?

 

[Joose]

Jede Klasse sollte wenn möglich in einer eigenen Datei stehen.
Mit Ausnahme von anonymen inneren Klassen sowie lokalen Klassen