ArrayList mit verschiedenen Datentypen in String konvertieren

Hallo zusammen,

ich bin auf der Suche nach einer möglichst eleganten (einfachen?) Möglichkeit die Variablen von SubListen der Reihe nach abzufragen und die Zahlenwerte (int/double) für eine Ausgabedatei (dat/txt) als String aufzubereiten. Die Oberliste hat "n" weitere Unterlisten, welche jeweils unterschiedlich viele Variablen besitzen können. Die Werte "null" sollten nicht ausgegeben werden und 0 nur bei speziellen Parametern. Die Variablentypen dieser ArrayList sind double, double[] und int bzw. int[]. Bei google & Co bin ich lach tagelanger Suche leider nicht fündig geworden, sodass ich auf eure Hilfe hoffe. :rtfm:

Meine Überlegung:
Sublisten jeweils einzeln ansprechen (geht das einfacher?) und hier mit einer for-Schleife oder dem Iterator (letzteres hat leider nicht funktioniert) die Variablen der Reihe nach abarbeiten, dabei:

1) Prüfen ob Wert "null" oder 0 ist
1a) Wenn ja: Muss Parameter mit ausgegeben werden? (diese Parameter sind nie Arrays!)
1aa) Wenn ja: Parameter als String konvertieren und für Ausgabe ablegen
1ab) Wenn nein: Überspringen

2) Zellinhalt ungleich null oder 0: Prüfen, ob Variable ein Array ist
2a) kein Array: siehe 1aa)
2b) ist Array: Dimension bestimmen und als String[] ablegen (ähnlich 1aa)

3) Parameter ausgeben


Zur Erklärung des Problems habe ich euch ein Minimalbeispiel erstellt - ich hoffe es hilft euch weiter.
Java:
package listArrayToStringOut;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class StringOutput extends ArrayList {

    public static void main(String[] args) {
	int intZahl = 0;
	double dZahl = 12.321;
	double[] dArray = { 1.234, 5.678 };

	int[] iArray = { 0, 4, 6 };
	double dZahl2 = 98.765;

	List<ExampleArray> exList = new ArrayList<ExampleArray>(0);
	ExampleArray model = new ExampleArray();
	model.setModelname("Testmodel");
	exList.add(model);

	ArrayList1 al1 = new ArrayList1();

	al1.setIntZahl(intZahl);
	al1.setdZahl(dZahl);
	al1.setdArray(dArray);
	model.addArrayList1(al1);

	ArrayListN alN = new ArrayListN();
	alN.setiArray(iArray);
	alN.setdZahl2(dZahl2);
	model.addArrayListN(alN);

	System.out.println("Testmodel angelegt.");

	StringOutput so = new StringOutput();
	so.CreateOutput(exList);

    }

    public void CreateOutput(List<ExampleArray> exList) {
	Field varAl1[] = ArrayList1.class.getDeclaredFields();
	Field varAlN[] = ArrayListN.class.getDeclaredFields();

	if (exList.size() == 1) {
	    for (ExampleArray exModel : exList) {

		List<ArrayList1> al1s = exModel.getAL1();
		if (al1s.size() == 1) {
		    for (ArrayList1 al1 : al1s) {

			// Write general settings
			System.out.println("$Beginn der Ausgabe");
			System.out.println();
			System.out.println();

			for (int i = 0; i < varAl1.length; i++) {
			    String varName = varAl1[i].getName();

			    // Steps:
			    // 1) Check, if variable is Array. if true check its
			    // dimension
			    Object obj = al1.get(i);
			    if (obj instanceof Object[]) {
				System.out.println("Ich bin ein Array!");
				// 1a) Check the dimension of the array
				// 1b) Check field type and convert all content
				// of variable to String
			    } else {
				// 2) Check field type and convert to String

			    }
			    // pure datatype
			    System.out.println(varName);
			    System.out.println();

			    // Case: 1d variable

			    // Case: 2d variable

			    // Case: 3d variable

			}
			System.out.println();
			System.out.println("$END");

		    }
		}
	    }
	}
    }
}

Java:
package listArrayToStringOut;

import java.util.ArrayList;
import java.util.List;

public class ExampleArray extends ArrayList {
    private String paramName;
    private String modelname;

    private List<ArrayList1> al1 = new ArrayList<ArrayList1>(0);
    private List<ArrayListN> alN = new ArrayList<ArrayListN>(0);

    public void addArrayList1(ArrayList1 al) {
	al1.add(al);
    } // end addAllgemein

    public void addArrayListN(ArrayListN al) {
	alN.add(al);
    } // end addDisturbance

    public String getParamName() {
	return paramName;
    }

    public void setParamName(String paramName) {
	this.paramName = paramName;
    }

    public String getModelname() {
	return modelname;
    }

    public void setModelname(String modelname) {
	this.modelname = modelname;
    }

    public List<ArrayList1> getAL1() {
	return al1;
    }

    public void setAL1(List<ArrayList1> al1) {
	this.al1 = al1;
    }

    public List<ArrayListN> getALN() {
	return alN;
    }

    public void setALN(List<ArrayListN> alN) {
	this.alN = alN;
    }

}

Java:
package listArrayToStringOut;

import java.util.ArrayList;

public class ArrayListN extends ArrayList {
    private int[] iArray;
    private double dZahl2;

    public int[] getiArray() {
	return iArray;
    }

    public void setiArray(int[] iArray) {
	this.iArray = iArray;
    }

    public double getdZahl2() {
	return dZahl2;
    }

    public void setdZahl2(double dZahl2) {
	this.dZahl2 = dZahl2;
    }
}

Java:
package listArrayToStringOut;

import java.util.ArrayList;

public class ArrayList1 extends ArrayList {
    private int intZahl;
    private double dZahl;
    private double[] dArray;

    public int getIntZahl() {
	return intZahl;
    }

    public void setIntZahl(int intZahl) {
	this.intZahl = intZahl;
    }

    public double getdZahl() {
	return dZahl;
    }

    public void setdZahl(double dZahl) {
	this.dZahl = dZahl;
    }

    public double[] getdArray() {
	return dArray;
    }

    public void setdArray(double[] dArray) {
	this.dArray = dArray;
    }
}


Ich habe versucht mich möglichst kurz zu fassen und hoffe es sind keine wichtigen Informationen flöten gegangen. Sollte dem so sein, fragt bitte nach, ich helfe gerne.

Habt ihr vielleicht eine viel einfachere Lösung? Bereits jetzt ganz herzlichen Dank für eure Hilfe.
 

Harry Kane

Top Contributor
Nehmen wir mal deine Klasse ExampleArray als Beispiel. Diese Klasse kann wie jede ArrayList Objekte aufnehmen. Ausserdem kann die Instanzvariable alN, die ja ebenfalls eine Instanz von ArrayList ist, ebenfalls Objekte aufnehmen, aber nur solche vom Typ ArrayListN. Und die ArrayListN Instanzen können, da sie ebenfalls ArrayLists sind, auch Objekte aufnehmen.
Wo möchtest du Sachen speichern?
- In ExampleArray? Dazu hast du kein Beispiel gezeigt.
- In der Instanzvariablen alN? Hierzu hast du ein Beispiel gezeigt. Damit das wie gezeigt funktioniert, muss ExampleArray aber nicht ArrayList erweitern!
- In den in alN gespeicherten Objekten? Hier fehlt wieder ein Beispiel. Du zeigst zwar in der main von StringOutput, wie du eine Instanz von ArrayListN anlegst und deren Methoden setiArray und setdZahl2 aufrufst, aber ich konnte kein Beispiel dafür entdecken, wie du eine Instanz von ArrayListN als normale ArrayList nutzt und dort beliebige Objekte reintust.

Zumindest bei der Klasse StringOutput kann ich keinen Grund erkennen, warum sie ArrayList erweitern sollte.
 
Wo möchtest du Sachen speichern?

Den Punkt hatte ich in meinem Eröffnungspost trotz größter Mühe vergessen - entschuldigung. Das Ziel ist das Schreiben einer Ausgabedatei für einen Optimierer. Diese Datei ist eine Textdatei und kann immer nur einen Datensatz (hier: ExampleArray) beinhalten. Dieser besitzt zur besseren Identifikation einen Namen (String modelname) und in meinem Beispiel die zwei Sublisttypen ArrayList1 und ArrayListN - in der Realität sind es knapp 10.

Überlegung:
Für die Ausgabedatei hatte ich mir das so gedacht, das ein Model (ExampleArray) in den beiden Sublisten jeweils genau einen Datensatz hat. Die Daten werden somit in allen drei Listen gespeichert. Die Struktur resultiert daraus, dass in al1 beispielsweise Geometriedaten und in alN z.B. Messdaten gespeichert werden sollen.

Struktur:
ExampleArray (kann verschiedene Modelle beinhalten, von denen jedoch immer nur eines in die Textdatei geschrieben werden soll)
- private String modelname
- ArrayList al1 (ein Datensatz für genau ein Modell)
- ArrayList alN (ein Datensatz für das gleiche Modell, analog zu al1)

Ich dachte mir also eine beliebige Liste in ExampleArray aufzurufen, welche in diesem Beispiel die drei Einträge modelname, al1 und alN besitzt. Via Schleife wollte ich die (hier: 3) Einträge ansprechen und ausgeben. Im Fall der beiden Sublisten wollte ich deren Einträge ebenfalls über eine Schleife abfragen. Hier muss dann allerdings die Unterscheidung zwischen Array (ja/nein) und dem Feldtyp (int oder double) getroffen werden. Letztendlich möchte ich die Inhalte der beiden Sublisten als String in die Textdatei schreiben, wobei ich alle nicht initiierten Variablen ("null") überspringe und nur bei bestimmten Schaltern (Wertebereich 0 oder 1, kein Array) ausgeben möchte.


Zumindest bei der Klasse StringOutput kann ich keinen Grund erkennen, warum sie ArrayList erweitern sollte.

Da ich die Sublisten mit einer Schleife ansprechen wollte, hatte ich mit den Methoden size() bzw. dem Iterator geliebäugelt und daher die drei Listen mit der ArrayList erweitert. Dann habe ich die Möglichkeit eine der beiden Methoden zu nutzen - so dachte ich zumindest...
 
Zuletzt bearbeitet:

Harry Kane

Top Contributor
und in meinem Beispiel die zwei Sublisttypen ArrayList1 und ArrayListN - in der Realität sind es knapp 10.
Sublisten oder Sublisttypen?

Für die Ausgabedatei hatte ich mir das so gedacht, das ein Model (ExampleArray) in den beiden Sublisten jeweils genau einen Datensatz hat. Die Daten werden somit in allen drei Listen gespeichert.
Zwei Sublisten, aber drei Listen? Das heisst, ein "Datensatz" wird je nach Typ in ArrayList1 oder ArrayListN, aber in jedem Fall auch in ExampleArray gespeichert? Dann würde ich ExampleArray eine "typunabhängige" ArrayList spendieren, anstatt ExampleArray von ArrayList abzuleiten.

ExampleArray (kann verschiedene Modelle beinhalten, von denen jedoch immer nur eines in die Textdatei geschrieben werden soll)
- private String modelname
- ArrayList al1 (ein Datensatz für genau ein Modell)
- ArrayList alN (ein Datensatz für das gleiche Modell, analog zu al1)

Ich dachte mir also eine beliebige Liste in ExampleArray aufzurufen, welche in diesem Beispiel die drei Einträge modelname, al1 und alN besitzt. Via Schleife wollte ich die (hier: 3) Einträge ansprechen und ausgeben. Im Fall der beiden Sublisten wollte ich deren Einträge ebenfalls über eine Schleife abfragen.
Was meinst du mit "Einträge"? Die Einträge in al1und alN? An die kommst du auch dann ran, wenn ExampleArray keine ArrayList ist?
Wenn dein ExampleArray mehrere Model enthält, wieso hat es dann nur einen modelnamen? Kennzeichnet der eine modelname das Model von den mehreren, welches gespeichert werden soll? Wenn ja, wie ermittelst du, welcher Eintrag aus al1 und alN zu dem model namen gehört? Für diesen Zweck würde sich eher eine HashMap<String, ArrayListN> empfehlen.
Ich tue mich übrigens schwer damit, die Anforderungen, die ich oben versucht habe zu verstehen, mit dem in Beziehung zu setzen, was in deiner CreateOutput-Methode von StringOutput passiert. Im einzelnen verstehe ich folgendes nicht:
- Du überprüfst die Länge der übergegebenen List<ExampleArray> auf 1. Nur wenn die Länge 1 ist, wird überhaupt was ausgegeben. Da könntest du auch gleich ein einzelnes ExampleArray übergeben.
- Du holst dir die al1 und alN Listen aus deinem ExampleArray, aber nicht die Elemente, die in dem ExampleArray selber gespeichert sind. Deswegen nochmal die Frage: warum soll ExampleArray ArrayList erweitern? Ist das für später irgendwann?
- Du überprüfts, ob al1s eine Länge von 1 hat, und nur dann wird Output erzeugt. Selbe Frage wie oben: Warum muss al1 aus ExampleArray eine ArrayList von ArrayList1 Objekten sein an statt eines einzelnen ArrayList1 Objektes?
- Per Reflection holst du dir alle von ArrayList1 deklarierten Felder. Ein Feld dürfte das Array sein, in dem ArrayList1, welches ja eine ArrayList ist, ihre eigenen Elemente speichert. Ich sehe aber nicht, wo du die "Speicherfähigeit" von ArrayList1 wirklich nutzt. Deshalb Frage wie oben: warum muss ArrayList1 ArrayList erweitern?
Ich glaube, mit ein paar selbstprogrammierten Klassen zur Datenhaltung, die intern ArrayListen nutzen anstatt von ihnen ableiten, wärst du besser beraten. Wie diese Klassen aussehen sollen, kann ich aber nicht sagen, weil ich noch nicht so richtig begriffen habe, was du denn nun genau machen willst.
 
Zunächst einmal ganz herzlichen Dank, dass du dir die Zeit nimmst und mit weiterhelfen möchtest. Ich werde mal versuchen nach bestem Wissen auf deine Fragen zu antworten - ich hoffe auch ausreichend (so lange programmiere ich noch nicht mit Java).

Sublisten oder Sublisttypen?
Sublisttypen - Ich habe die Versuchseigenschaften, welche in Java als Variablen abgelegt werden gruppiert und für jede Gruppe eine Sublist erstellt (hier: ArrayList1 und ArrayListN).

Zwei Sublisten, aber drei Listen? Das heisst, ein "Datensatz" wird je nach Typ in ArrayList1 oder ArrayListN, aber in jedem Fall auch in ExampleArray gespeichert? Dann würde ich ExampleArray eine "typunabhängige" ArrayList spendieren, anstatt ExampleArray von ArrayList abzuleiten.

Wenn ich dich richtig verstanden habe, ist das nicht ganz der Fall. Ich versuche es nochmal zu erklären:
Ich habe mehrere Versuchsmodelle und lege für jedes Modell eine Liste vom Typ ExampleList an. Wähle ich ein Versuchsmodell aus dieser Liste aus, besitzt diese Liste (= dieses Modell) genau eine Sublisteneintrag vom Typ ArrayList1 und ArrayListN. Um es anschaulicher zu gestalten hatte ich das Beispiel gebracht, dass in dem einen Listentyp Geometrie- und in dem anderen Listentyp Messdaten abgelegt werden.

Den Punkt mit der typabhängigen ArrayList habe ich nicht ganz verstanden. Könntest du mir das bitte nocheinmal erklären? Hast du vielleicht ein Beispiel?

Was meinst du mit "Einträge"? Die Einträge in al1und alN? An die kommst du auch dann ran, wenn ExampleArray keine ArrayList ist?
Zugegeben "Einträge" war vielleicht nicht ganz richtig ausgedrückt - vielleicht trifft es Attribute besser. Eine Liste vom Typ ExampleList hat ja die "Einträge" bzw. Attribute modelname (String) und die (hier) zwei Sublisten... Wie ich daran komme weiß ich gerade noch nicht. Ich dachte mir, dass es mit einer ArrayList recht elegant gelöst wäre. Wenn es einfacher geht (= mmE eleganter) geht, ist das prima.

Wenn dein ExampleArray mehrere Model enthält, wieso hat es dann nur einen modelnamen? Kennzeichnet der eine modelname das Model von den mehreren, welches gespeichert werden soll? Wenn ja, wie ermittelst du, welcher Eintrag aus al1 und alN zu dem model namen gehört?
Für jedes Modell wird eine (neue) eigene Liste mit dem Typ ExampleList und somit auch für jedes Modell eine eigene Subliste von Typ ArrayList1 bzw. ArrayListN angelegt. Der Aufruf würde dann über den Modelnamen erfolgen und die Sublisten der Oberliste vom Typ ExampleArray würden über eine Schleife/den Iterator abgerufen werden.

Für diesen Zweck würde sich eher eine HashMap<String, ArrayListN> empfehlen.
Mit Hashmaps habe ich bis dato keine Berührung gehabt, weshalb ich daran nicht gedacht hatte. Ist das für meinen Anwendungsfall geeigneter?

Du überprüfst die Länge der übergegebenen List<ExampleArray> auf 1. Nur wenn die Länge 1 ist, wird überhaupt was ausgegeben. Da könntest du auch gleich ein einzelnes ExampleArray übergeben.
In der derzeitigen Ausbaustufe ist angedacht, dass nur ein Model (eine Liste) vom Typ ExampleList vorhanden ist. Sobald die Ausgabe steht, wird dies anders sein.

Du holst dir die al1 und alN Listen aus deinem ExampleArray, aber nicht die Elemente, die in dem ExampleArray selber gespeichert sind. Deswegen nochmal die Frage: warum soll ExampleArray ArrayList erweitern? Ist das für später irgendwann?
Die Elemente aus dem Array wollte ich dann ja via Schleife abfragen. Den Datentyp (int/double und die Diemnsion des Arrays) prüfen, in Strings bzw. String[] konvertieren und somit für die Ausgabe vorbereiten. Leider weiß ich nicht wie - weshalb ich den Beitrag hier geschrieben habe.

Du überprüfts, ob al1s eine Länge von 1 hat, und nur dann wird Output erzeugt. Selbe Frage wie oben: Warum muss al1 aus ExampleArray eine ArrayList von ArrayList1 Objekten sein an statt eines einzelnen ArrayList1 Objektes?
Genau, ich überprüfe die Länge von al1s, weil es nur eine Liste zu einem Modell von diesem Listentyp geben darf - zwei Datensätze für Geometrien oder Messdaten etc. sind nicht zulässig. Um sicherzugehen, dass dem auch so ist, habe ich das geprüft.

Per Reflection holst du dir alle von ArrayList1 deklarierten Felder. Ein Feld dürfte das Array sein, in dem ArrayList1, welches ja eine ArrayList ist, ihre eigenen Elemente speichert. Ich sehe aber nicht, wo du die "Speicherfähigeit" von ArrayList1 wirklich nutzt. Deshalb Frage wie oben: warum muss ArrayList1 ArrayList erweitern?
Die Variablennamen frage ich ab, weil die Ausgabedatei diese benötigt. Eine Zeile in dieser Datei könnte beispielsweise so aussehen (Zahlen durch Tab oder Leerzeichen voneinander getrennt):
dArray = 1,234 5,678
Wenn die Erweiterung nicht erforderlich ist, kann ich die rausnehmen. Ich hatte nur nach einer prinzipiellen Lösungsvariante gesucht und hab habe ich alle drei Listen mit aufgenommen/erweitert. Ich muss diese ja später via Schleife abfragen füpr die Ausgabe und einen anderen Lösungsweg habe ich - trotz googleln und Co - nicht gefunden.

Ich glaube, mit ein paar selbstprogrammierten Klassen zur Datenhaltung, die intern ArrayListen nutzen anstatt von ihnen ableiten, wärst du besser beraten. Wie diese Klassen aussehen sollen, kann ich aber nicht sagen, weil ich noch nicht so richtig begriffen habe, was du denn nun genau machen willst.
Das kann sehr gut sein und daran dachte ich auch schon. Vielleicht wurde das Bild einwenig klarer. Vielleicht habe ich mich anfangs einfach zu kurz gefasst.

Danke dir für deine großartige Hilfe.
 

Harry Kane

Top Contributor
Ist "ExampleList" das gleich wie "ExampleArray"? Ich versuche gerade mich in deinen Anwendungsfall hineinzudenken, und jede sprachliche Ungenauigkeit macht das natürlich nicht leichter.
Eine Liste vom Typ ExampleList hat ja die "Einträge" bzw. Attribute modelname (String) und die (hier) zwei Sublisten... Wie ich daran komme weiß ich gerade noch nicht. Ich dachte mir, dass es mit einer ArrayList recht elegant gelöst wäre.
Das ist z. B. ein Satz, den ich nicht verstehe. Rein intuitiv würde ich beim Wort "Einträge" an die Elemente in der Liste denken. "modelname"und die Sublisten von ExampleArray oder ExampleList sind aber definitiv keine "Einträge", sondern ganz normale Attribute/Felder/Eigenschaften, an die du ganz einfach per setter rankommst. Ich verstehe nicht, wieso du eine ArrayList brauchst, um an "modelname" ranzukommen, vor allem deshalb, weil "modelname" gar nicht in der ArrayList drinsteht.
Ich habe mehrere Versuchsmodelle und lege für jedes Modell eine Liste vom Typ ExampleList an. Wähle ich ein Versuchsmodell aus dieser Liste aus, besitzt diese Liste (= dieses Modell) genau eine Sublisteneintrag vom Typ ArrayList1 und ArrayListN.
Noch ein Satz den ich nicht verstehe: du hast mehrere Versuchsmodelle und legst für jedes Modell ein Objekt vom Typ ExampleList an. Das heisst, es gibt eine 1:1 Beziehung zwischen Versuchsmodell und ExampleList. Dann schreibst du, dass du "aus dieser Liste" ein Versuchsmodell auswählst. Wenn "diese Liste" die ExampleList ist, frage ich mich, warum sie auf einmal mehrere Versuchsmodelle enthält, aus denen man auswählen kann. Wenn "diese Liste" was anderes ist, frage ich mich: was ist sie?
 
Ich hatte den Beitrag eben schonmal komplett fertig, bevor der Inhalt plötzlich verschwunden ist - ich hoffe ich vergesse daher jetzt nichts.

Zuerst jedoch noch einmal ganz ganz herzlichen Dank für deine Mühe. In meinem ersten Beitrag hatte ich mich evtl. nicht ganz klar ausgedrückt, vielleicht ist das bewählte Minimalbeispiel auch nicht ganz so gut geeignet. Bei der nächsten Frage, werde ich das im Hinterkopf behalten.

Aber nun zu deinen Nachfragen:
Ist "ExampleList" das gleich wie "ExampleArray"?
Nein, es sind zwei verschiedene Listen. Für jedes Versuchsmodel wird eine Liste vom Typ ExampleList angelegt. Diese Liste erhält einen String und zwei Sublisten. Diese SUblisten beinhalten die Mess- bzw. die Geometriedaten. Die Messdaten werden in einer Sublist vom Typ ArrayList1 und die Geometriedaten in einer Liste vom Typ ArrayListN abgelegt - zumindest in unserem kleinen Beispiel. Ich hatte ja erwähnt, dass es noch acht weitere Kategorien gibt, deren Daten in Sublisten gespeichert sind.

Zur besseren Übersicht möchte ich dir ein kleines Schema zeigen. Darin sind zwei Versuchsmodelle angelegt:
Code:
Liste 0 (Typ ExampleList)
- String modelname = "Versuch 1"
- al1, Liste 0 (Typ ArrayList1) - beinhaltet Messdaten
     - private int intZahl;
     - private double dZahl;
     - private double[] dArray;    
- alN, Liste 0 (Typ ArrayListN) - beinhaltet Geometriedaten
     - private int[] iArray;
     - private double dZahl2;

Liste 1 (Typ ExampleList)
- String modelname = "Versuch 2"
- al1, Liste 0 (Typ ArrayList1) - beinhaltet Messdaten
     - private int intZahl;
     - private double dZahl;
     - private double[] dArray;    
- alN, Liste 0 (Typ ArrayListN) - beinhaltet Geometriedaten
     - private int[] iArray;
     - private double dZahl2;


Das ist z. B. ein Satz, den ich nicht verstehe. Rein intuitiv würde ich beim Wort "Einträge" an die Elemente in der Liste denken. "modelname"und die Sublisten von ExampleArray oder ExampleList sind aber definitiv keine "Einträge", sondern ganz normale Attribute/Felder/Eigenschaften, an die du ganz einfach per setter rankommst. Ich verstehe nicht, wieso du eine ArrayList brauchst, um an "modelname" ranzukommen, vor allem deshalb, weil "modelname" gar nicht in der ArrayList drinsteht.

Da hat deine Intuition dir recht gegeben: Mit "Einträge" meinte ich die "Attribute". Da ich in den beiden Sublisten vom Typ ArrayList1 und ArrayListN wesentlich mehr Attribute habe, als die oben gezeigten (wir reden von etwa 150 - 180 Attributen pro Sublist-Typ) wollte ich mit einer Schleißte die getter abfragen. Beispielsweise durch etwas wie (ich weiß es ist nicht ganz richtig, geht nur ims Prinzip):

Code:
for(int i = 0; i<ArrayList1.size(), i++){
   String value = ArrayList1.get(i);
}


Ich bin mir nicht sicher, aber vielleicht ergibt sich diese Frage bereits aus eminer Antwort oben:
... du hast mehrere Versuchsmodelle und legst für jedes Modell ein Objekt vom Typ ExampleList an. Das heisst, es gibt eine 1:1 Beziehung zwischen Versuchsmodell und ExampleList. Dann schreibst du, dass du "aus dieser Liste" ein Versuchsmodell auswählst. Wenn "diese Liste" die ExampleList ist, frage ich mich, warum sie auf einmal mehrere Versuchsmodelle enthält, aus denen man auswählen kann. Wenn "diese Liste" was anderes ist, frage ich mich: was ist sie?
In Bezug zu meinem Schoma oben, würde ich ein Model durch String modelname auswählen. Dadurch kann ich die dazugehörigen Attribute abfragen. Wie ich diese Attribute abfrage und prüfe (Feldtyp (int oder double) zulässiges Feld etc. und letztlich die Ausgabe als String ist die Frage. Daher hatte ich überhaupt den Beitrag in dieses Forum geschrieben...

Ich hoffe du hast mein Problem besser verstehen können.


Viele Grüße :)
 
Benötigt ihr eventuell weitere Informationen von mir? War das Beispiel nicht "anschaulich" oder eher zu verwirrend? Vielleicht kann ich noch ein paar wichtige Informationen geben - das Problem besteht noch immer :)
 

Harry Kane

Top Contributor
Ich vermute, du gast eine oder mehrere Klassen, die wiederum zahlreiche Instanzvariablen von verschiedenen Typen haben könne, und du möchtest es vermeiden, für jedes der zahlreichen Felder eine setter/getter zu schreiben und diese sette/getter beim Laden/speichern deiner Klasse aufurfen zu müssen?
Dann war der Ansatz mit der ArrayList schonmal richtig. Jetzt fehlt nur noch eine Möglichkeit, mit verschiedenen Variablentypen umgehen zu könne.
Ich habe früher mal angefangen so was zu entwickeln. Der Ansatz sah ungefähr so aus:
1. Eine Klasse ParameterList, die als private Variable eine Liste von Instanzen der Klasse Parameter hat.
2. Eine Klasse Parameter<T>, die im Prinzip eine Variable und einen Namen beinhaltet, und die Fähigkeit hat, sich in einen String zu schreiben und sich aus einem String zu rekonstruieren.
Ich habe mir gerade mal was aus dem Gedächtnis zusammengezimmert. Ist sicher nicht fehlerfrei, aber kann dir ev. einen Denkanstoss geben.

Java:
class ParameterList {

    private ArrayList<Parameter> parameters = new ArrayList<Parameter>();

    public String writeParameter(int i) {
        Parameter p = parameters.get(i);
        StringBuffer buf = new StringBuffer();
        buf.append(p.getClass().getName()).append("#")
                .append(p.getName()).append("#")
                .append(p.valueToString()).append(System.getProperty("line.separator"));
        return buf.toString();
    }

    public void readParameter(String asString) {
        String[] splitted = asString.split("#");
        try{
            Parameter p = (Parameter)Class.forName(splitted[0]).getConstructor(String.class).newInstance(splitted[1]);
            p.stringToValue(splitted[2]);
            parameters.add(p);
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }

    public int getParameterCount() {
        return parameters.size();
    }
}

abstract class Parameter<T> {

    private String name;
    private T value;

    Parameter(T value, String name) {
        this.value = value;
        this.name = name;
    }

    Parameter(String name) {
        this.name = name;
    }

    public T getValue() {
        return value;
    }

    public String getName() {
        return name;
    }

    public abstract String valueToString();

    public abstract void stringToValue(String s);

    protected void setValue(T value) {
        this.value = value;
    }
}

class StringParameter extends Parameter<String> {

    StringParameter(String value, String name) {
        super(value, name);
    }

    public String valueToString() {
        return getValue().toString();
    }

    public void stringToValue(String s) {
        setValue(s);
    }
}

class IntArrayParameter extends Parameter<int[]> {

    IntArrayParameter(int[] value, String name) {
        super(value, name);
    }

    public String valueToString() {
        StringBuffer buf = new StringBuffer();
        for (int i : getValue()) {
            buf.append(String.valueOf(i)).append(";");
        }
        return buf.substring(0, buf.length() - 1).toString();
    }

    public void stringToValue(String s) {
        String[] splitted = s.split(";", -1);
        int[] value = new int[splitted.length];
        for (int i = 0; i < splitted.length; i++) {
            value[i] = Integer.parseInt(splitted[i]);
        }
        setValue(value);
    }
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
M ArrayList oder LinkedList Allgemeine Java-Themen 10
C Sortieren und Selektieren einer ArrayList<Point3D> Allgemeine Java-Themen 6
A Einzelne Objekte und Unterobjekte einer ArrayList ausgeben Allgemeine Java-Themen 53
T Remove bei ArrayList funktioniert nicht Allgemeine Java-Themen 2
B Type mismatch: cannot convert from Graph.Edge to ArrayList<Graph.Edge> Allgemeine Java-Themen 21
R ArrayList Allgemeine Java-Themen 4
G jToggleButton in Array/ArrayList Allgemeine Java-Themen 12
J ArrayList, ganze Zeilen löschen oder überspringen Allgemeine Java-Themen 4
L ArrayList sortieren Allgemeine Java-Themen 2
C ArrayList Problem Allgemeine Java-Themen 3
O Datentypen Wie kann ich den Typ einer ArrayList abfragen ? Allgemeine Java-Themen 7
S Best Practices CopyConstrutor mit ArrayList Allgemeine Java-Themen 1
S ArrayList Design Allgemeine Java-Themen 4
S Array dynamisieren oder ArrayList verwenden? Allgemeine Java-Themen 17
L ArrayList mit String Arrays in ein Array umwandeln Allgemeine Java-Themen 1
H Elemente aus ArrayList in Array speichern Allgemeine Java-Themen 8
MiMa Person in einer Arraylist hinzugügen mit Prüfung ? Allgemeine Java-Themen 6
X Adjazenzliste ohne ArrayList Allgemeine Java-Themen 6
X Output von ArrayList Allgemeine Java-Themen 3
H Stream in ArrayList umwandeln Allgemeine Java-Themen 2
H Mehrere Datentypen in einer Arraylist speichern Allgemeine Java-Themen 9
H Arraylist mit anderer ArrayList überschreiben Allgemeine Java-Themen 17
MiMa ArrayList sortieren?? Allgemeine Java-Themen 5
Curtis_MC Pointer mit ArrayList vergleichen Allgemeine Java-Themen 6
F ArrayList`s in Klassen mit Getter/Setter Allgemeine Java-Themen 8
W Array vs. ArrayList vs. HashMap Allgemeine Java-Themen 20
F Arraylist vollständig abspeichern und laden Allgemeine Java-Themen 1
R Arraylist in andere Klasse leiten und bearbeiten Allgemeine Java-Themen 10
D ArrayList Indexlänge ändern Allgemeine Java-Themen 2
E Elemente innerhalb einer ArrayList vergleichen Allgemeine Java-Themen 33
K ursprüngliche ArrayList ändert sich bei Übergabe in Methode Allgemeine Java-Themen 18
N Mehrdimensionale ArrayList mischen Allgemeine Java-Themen 10
S JTable - mehrere ausgewählte Rows in ArrayList Allgemeine Java-Themen 5
MiMa Date aus einer ArrayList<Date> holen ?? Allgemeine Java-Themen 5
MiMa ArrayList Rückgabewerte aus einer Funktion Allgemeine Java-Themen 15
L CSV File lesen, in ArrayList speichern und ausgeben Allgemeine Java-Themen 3
M Was geschieht mit Java-Klasse, die aus ArrayList entfernt wird? Allgemeine Java-Themen 10
M Methoden Generische Methode für ArrayList Allgemeine Java-Themen 7
T Collections ArrayList Sortieren Allgemeine Java-Themen 4
P GUI: ArrayList anzeigen funktioniert nicht Allgemeine Java-Themen 5
H ArrayList: Leere Elemente finden? Allgemeine Java-Themen 2
GreenTeaYT Verständnisprobleme zur Arraylist Allgemeine Java-Themen 1
T Methoden Methode zum durchsuchen einer ArrayList Allgemeine Java-Themen 8
K ArrayList sortieren Allgemeine Java-Themen 16
A Bestimmte Inhalte aus ArrayList 1 in ArrayList 2 kopieren Allgemeine Java-Themen 6
S Mehrdimensionales ArrayList ins HashSet Allgemeine Java-Themen 10
C ArrayList Allgemeine Java-Themen 8
Streeber Probleme mit AWT-EventQueue: ArrayList Elemente hinzufügen Allgemeine Java-Themen 1
F Methoden Arraylist weiterverwenden nach methoden Aufruf Allgemeine Java-Themen 2
Z NullPointerException beim Schreiben einer ArrayList in eine Datei Allgemeine Java-Themen 6
L Von ArrayList abgeleitete Klasse nur mit bestimmten Objekten füllen Allgemeine Java-Themen 1
K Array in ArrayList Allgemeine Java-Themen 16
Paul15 2D Arraylist in Jtable Allgemeine Java-Themen 1
Paul15 Arraylist 2D Allgemeine Java-Themen 8
B ArrayList in ein Objekt legen Allgemeine Java-Themen 1
Neumi5694 Datentypen ArrayList vs TreeMap Allgemeine Java-Themen 6
F ArrayList Allgemeine Java-Themen 11
X ArrayList will nicht so wie ich will. Hilfe Allgemeine Java-Themen 8
N ArrayList in eigenem Object nicht richtig serialisierbar Allgemeine Java-Themen 14
Z Elemente einer ArrayList von rechts wegnehmen Allgemeine Java-Themen 5
W Arraylist Text Suchen und Datei löschen Allgemeine Java-Themen 5
R ArrayList und HashMap Allgemeine Java-Themen 7
T ArrayList zeilenumbruch entfernen Allgemeine Java-Themen 13
D Arraylist/For Schleife/Scanner Allgemeine Java-Themen 30
E ArrayList Anzahl der gleichen Elemente Allgemeine Java-Themen 4
Doopy ArrayList plötzlich leer Allgemeine Java-Themen 2
D Arraylist eigener Klasse an iReport übergeben Allgemeine Java-Themen 7
L ArrayList Inhaltstyp. Allgemeine Java-Themen 5
Z Klassen ArrayList selbst machen Allgemeine Java-Themen 5
J Arraylist speichern und laden? Allgemeine Java-Themen 5
C Generics Objekt in ArrayList Allgemeine Java-Themen 2
D ArrayList index auf gültigkeit prüfen Allgemeine Java-Themen 12
M ArrayList<String> Frage Allgemeine Java-Themen 7
O ArrayList kaputt?! Allgemeine Java-Themen 5
M ArrayList<Foo> in ein Foo[] konvertieren? Allgemeine Java-Themen 8
Bananabert Abstract ArrayList Allgemeine Java-Themen 4
A Collections Array-Elemente in ArrayList kopieren ohne Schleife Allgemeine Java-Themen 7
O ArrayList - Serialisierungs-Problem Allgemeine Java-Themen 11
M JTable + ArrayList Allgemeine Java-Themen 3
M Datentypen ArrayList in Integer konvertieren Allgemeine Java-Themen 3
O Collections ListIterator gibt Inhalt von ArrayList nicht aus Allgemeine Java-Themen 3
Madlip Variablen 3 Werte aus ArrayList und weiter ... Allgemeine Java-Themen 4
S arraylist nach n. Eintrag numerisch Sortiren Allgemeine Java-Themen 5
O Problem beim Auslesen einer Arraylist von JComboBoxen Allgemeine Java-Themen 2
R Threads korrekte Synchronisation bei Vector und ArrayList Allgemeine Java-Themen 6
M Kovariante Rückgabewerte mit ArrayList Allgemeine Java-Themen 3
H LinkedList<LinkedList<String>> nach ArrayList<ArrayList<String>> ? Allgemeine Java-Themen 9
E NetBeans Vector durch ArrayList ersetzen Allgemeine Java-Themen 4
Maxim6394 Problem mit ArrayList Allgemeine Java-Themen 5
E Berechnung in Arraylist Allgemeine Java-Themen 10
E ArrayList mit unbekannter Größe Allgemeine Java-Themen 8
V Fork Join bei Arraylist Allgemeine Java-Themen 6
H Fehler in Arraylist Allgemeine Java-Themen 2
S Datensätze in eine ArrayList<Movie> speichern Allgemeine Java-Themen 13
S Alle Kombinationen aus ArrayList - Potenzmenge Allgemeine Java-Themen 7
V ArrayList vergleichen mit .equals? Allgemeine Java-Themen 13
J ArrayList-Problem Allgemeine Java-Themen 16
S Von einer ArrayList in die andere schreiben? Allgemeine Java-Themen 6
S ArrayList<JLabels> "malen" Allgemeine Java-Themen 4
E ArrayList in ArrayList, Referenzierungsproblem Allgemeine Java-Themen 7

Ähnliche Java Themen

Neue Themen


Oben