# ArrayList mit verschiedenen Datentypen in String konvertieren



## Meister_Lampe (24. Nov 2014)

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.

```
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");

		    }
		}
	    }
	}
    }
}
```


```
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;
    }

}
```


```
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;
    }
}
```


```
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 (24. Nov 2014)

Was ich an deinem beispiel schon nicht verstehe: Warum leitest du alle deine Klassen von ArrayList ab?


----------



## Meister_Lampe (25. Nov 2014)

Harry Kane hat gesagt.:


> Was ich an deinem beispiel schon nicht verstehe: Warum leitest du alle deine Klassen von ArrayList ab?



Moin Harry, danke für deine Frage. Ich hatte den Bezug zur ArrayList anfangs nicht mit eingeplant, dann jedoch hinzugenommen, damit ich via Iterator/size() der ArrayList durch die Listen schreiten kann. Sollte ich das anders tun?


----------



## Harry Kane (25. Nov 2014)

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.


----------



## Meister_Lampe (25. Nov 2014)

Harry Kane hat gesagt.:


> 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. 




Harry Kane hat gesagt.:


> 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...


----------



## Harry Kane (25. Nov 2014)

Meister_Lampe hat gesagt.:


> und in meinem Beispiel die zwei Sublisttypen ArrayList1 und ArrayListN - in der Realität sind es knapp 10.


Sublisten oder Sublisttypen?



Meister_Lampe hat gesagt.:


> 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.



Meister_Lampe hat gesagt.:


> 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)_
> ...


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.


----------



## Meister_Lampe (26. Nov 2014)

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). 



Harry Kane hat gesagt.:


> 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_).



Harry Kane hat gesagt.:


> 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?



Harry Kane hat gesagt.:


> 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. 



Harry Kane hat gesagt.:


> 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.



Harry Kane hat gesagt.:


> 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?



Harry Kane hat gesagt.:


> 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.



Harry Kane hat gesagt.:


> 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.



Harry Kane hat gesagt.:


> 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.



Harry Kane hat gesagt.:


> 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.



Harry Kane hat gesagt.:


> 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 (27. Nov 2014)

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?


----------



## Meister_Lampe (29. Nov 2014)

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:


Harry Kane hat gesagt.:


> 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:

```
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;
```




Harry Kane hat gesagt.:


> 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):


```
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:


Harry Kane hat gesagt.:


> ... 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


----------



## Meister_Lampe (8. Dez 2014)

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 (8. Dez 2014)

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.


```
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);
    }
}
```


----------

