Java Generics

[redbomber]

Hi zusammen,
hab mal wieder eine dumme Frage:

Ich besitze eine Klasse, die je nachdem was für eine Datei eingelesen wird, einen Array von einem bestimmten Typ enthält (Der Typ wird in dem File definiert).

So momentan mache ich es wie folgt:

Habe 3 Arrays

protected ArrayList<Integer> data01 = new ArrayList<Integer>();
	protected ArrayList<Short> data02 = new ArrayList<Short>();
	protected ArrayList<Double> data03 = new ArrayList<Double>();

und befülle EINEN davon, je nachdem welcher Datentyp ausgelesen wurde:

protected void fillDataArray(String name){
		if(dataType == DataType.SHORT){
			data02.add(Short.valueOf(name));
		} else if(dataType == DataType.DOUBLE){
			data03.add(Double.valueOf(name));
		} else if(dataType == DataType.INT){
			data01.add(Integer.valueOf(name));
		}
	}

Will ich an den Array kommen, so brauche ich wieder 3 Methoden:

public ArrayList<Integer> getDataArray(){
		return data01;
	}

usw...


Wie kann ich den Datentyp variabel halten, dass ich mir somit zum einen die drei Arrays spare und zum anderen die vielen identischen Methoden?

 

[Schandro]

Short, Double und Integer sind von Number abgeleitet.

Du könntest aber auch einfach nur double's einlesen (und andere Werte nach double casten, verändert nix...) , würd alles einfacher machen

 

[didjitalist]

oder einfach einen eigenen typ dafür definieren.

interface Value
{
  DataType getType();
  double doubleValue();
  int intValue();
  short shortValue();
}

 

[redbomber]

ja aber wenn ich alles nach double caste habe ich das Problem dass mir (im Vergleich zu short) viel Platz verloren geht,
also bei sehr großen Datenmengen.

 

[Zed]

Bei sehr großen Datenmengen geht dir durch die automatisch allokierung der Listen viel Speicherplatz verloren.

Eine Liste wird mit 10 Plätzen allokiert. Wird der Platz knapp wir er verdoppelt. Bei 1281 Daten hat das Array 2560 Plätze, bei 2561 -> 5120 usw.

Du sollest dir

protected List<Integer> data01 = new ArrayList<Integer>();

angewöhnen

 

[SlaterB]

weil ich es auch früher gerne falsch gemacht habe:
der Speicherplatz wird nicht verdoppelt, sondern steigt um 2/3,
von 2560 z.B. auf 4250

und man kann doch trotzdem zwischen Double und Integer sparen

und eine List<Number> kann immer noch alle unterschiedlichen Objekte aufnehmen

und dann sind allerdings diese Objekte sowieso viel größer als primitive Werte,
da solltest du, wenn du wirklich auf Platz Wert legst, int[], double[] usw. verwenden

 

[Zed]

Bei 1 000 000 double Werten reden wir von ca. 7,6MB. Den Wert finde ich auf einem Desktop Rechner ziemlich unrelevant.

Die Frage ist wie viele Werte werden erwartet?

 

[redbomber]

worin besteht denn genau der Unterschied von:

protected List<Integer> data01 = new ArrayList<Integer>();

zu:

protected ArrayList<Integer> data01 = new ArrayList<Integer>();

 

[Ebenius]

worin besteht denn genau der Unterschied von [...]

Der Unterschied ist, dass im ersten Fall die Implementierung nur an das List-Interface gebunden ist. Grundsätzlich sollte man wo es möglich ist Interfaces referenzieren und nicht konkrete Implementationen. Wenn Du später beispielsweise Engpässe mit einer bestimmten Listenimplementierung hast, kannst Du eine neue Implementierung auswählen (oder selbst schreiben) und einfach einsetzen, ohne Gefahr zu laufen, dass an einer anderen Stelle etwas nicht mehr funktioniert, weil implementierungsabhängige (zusätzliche) Methoden verwendet wurden.

Ebenius

 

[Der Müde Joe]

im ersten Fall spricht du die Liste über das Interface an. Im 2. direkt über die Klasse.
Im ersten Fall kannst du die ArrayList in eine ? LinkedList wechseln ohne Probleme... im zweiten Fall dürfte das schwerer werden.
Im ersten Fall sagt du nur, das es irgend eine Liste ist, mit den Eigenschaften einer Liste, was es ist aber nicht, im 2 Fall ist es genau diese spezielle Liste (ArrayList) mit ihren speziellen eigenschaften und Methoden...so ca.

 

[Landei]

Du könntest auch einfach deine "umgebende" Klasse parametrisieren, dann brauchst du auch das seltsame "dataType" nicht (was wenig objektorientiert aussieht):

public class MeinDateiEinleser<T extends Number> {
   protected List<T> dataArray = new ArrayList<T>(); 
   public List<T>getDataArray() {
      return dataArray
   }
   public void addData(T t) {
      dataArray.add(t);
   }
}

//Angenommen, es ist ein Integer-File
MeinDateiEinleser<Integer> intEinleser = new MeinDateiEinleser<Integer>();
intEinleser.addData(4711)
List<Integer> meineIntList = inteinleser.getDataArray();