ArrayList in verketteter Liste

[Reen]

Servus Leute!

Ich muss das hier nomma neu und sauber und mit weniger Kram vom Code her posten. Habe jetzt mal allen unwichtigen Schice entfernt.

Und zwar lege ich ein ByteArray an. Dieses ByteArray beschreibe ich mit einem String. Dann schreibe ich das ByteArray in eine ArrayList. Die ArrayList wird wiederrum in eine verkettete Liste geschrieben. Das klappt auch soweit. Nur bei der Ausgabe geht was schief. Listenelement 1 beinhaltet immer Listenelement 2. Und zwar liegt das irgendwie an den Byte-Array's. Definiere ich für jede ArrayList ein neues Byte-Array (z.B. für "al1" dann index_2) klappts bzw. lasse ich die Byte-Arrays generell außen vor und schreibe nur Strings rein gehts auch.

Woran liegt das denn? Das muss doch reichen, wenn ich nur ein ByteArray (index1) definiere und immer wieder neu beschreibe oder greift der bei der Ausgabe immer wieder auf das letzte ByteArray zurück, was ja noch irgendwo im Speicher liegt? Aber was einmal in der Liste liegt, dass liegt doch auch da drin, zumal er ja dann bei der Ausgabe wiederrum ein neue ArrayList Objekt anlegt.

Bitte gebt mir mal einen Tipp wie das anders oder besser gelöst werden kann. Es soll ja nicht nur wie hier im Bsp. ein oder zwei ByteArrays mit dem Index beschrieben werden, sondern einige tausend.

Danke
Reen

EDIT: Code entfernt

 

[SlaterB]

da ist keine Kunst dabei,
du hast genau ein Array, das du in beide Listen einfügst,

Speicher ist begrenzter Platz, du musst schon genau sagen, wann du ein oder zwei verschiede Array meinst:

Array in Liste1 einfügen,
Array = new Array
Array in Liste2 einfügen,

oder gleich getrennte Variablen
byte[] index_1 = new byte[7];
byte[] index_2 = new byte[7];

dann wirds noch übersichtlicher

 

[Reen]

Danke....

Ich war bzw. bin eigentlich noch immer der Meinung, wenn ich ein Array definiere, dieses Array mit dem String "1" fülle, dann damit in die ArrayList und dann in die Liste (für Element 1) schreibe, dass es dort drin dann auch so bei der Ausgabe bleibt.

Im nächsten Schritt würde ich jetzt wieder das "gleiche" Array nehmen, aber mit dem String "2" überschreiben, und der Rest wie oben weiter und in Listenelement 2 eintragen. Bei der Ausgabe greift er ja theo. nich auf das alte ByteArray zu. Er guggt ja was im Listenelement steht und erstellt wieder ein neues Objekt für die Ausgabe. Ich habs ja auch ursprünglich in eine Datei geschrieben, da hat er ja auch nich nur das letzte ELement reinschrieben, sondern alle der Reihenfolge nach. Also mit steigendem Index.

Sehe ich das jetzt so falsch, dass das eben gerade nich geht, so wie ich es beschrieben habe? Bissl wundern tuts mich schon!



Naja....eigentlich werden ja die ArrayListen dann in einer Schleife in die einzelnen ListenElemente geschrieben. Habe gerade rausgefunden, wenn ich die Array's unmittelbar bei jedem Schleifendurchlauf neu anlege, dann klappts auch wieder mit der Ausgabe. Und die Ausgabe zeigt nicht für alle ListenElemente den letzen Eintrag in die Liste an.

mfg
Reen

 

[SlaterB]

siehst du wohl alles richtig nun, wenn auch bisschen kompliziert ausgedrückt,

Objekte bleiben einzelne Objekte, werden nicht unaufgefordert kopiert,
stattdessen werden Referenzen darauf gespeichert,

wenn sich ein Objekt ändert, dann in allen Listen, denn überall ist das gleiche Objekt,


wenn du aber der lokalen Variablen index_1 nach dem Einfügen in ein eine Liste ein neues Array zuweist, dann bleibt das ursprüngliche wie es ist,
denn das Objekt bleibt unverändert,
es wird nur irgendeiner Variablen eine neue Referenz gegeben

 

[Guest]

Hallo....das erklärt schon einiges.

for (i=0; i<anzahlint; i++)
				{	
					byte[] index = new byte[7];		
            }

wenn du aber der lokalen Variablen index_1 nach dem Einfügen in ein eine Liste ein neues Array zuweist, dann bleibt das ursprüngliche wie es ist,
denn das Objekt bleibt unverändert,
es wird nur irgendeiner Variablen eine neue Referenz gegeben

Du meinst also den Fall, wie's in der Schleife dargestellt ist. Hier wird doch aber auch immer wieder auf dem gleichen Objekt (nämlich auf "index") gearbeitet ODER wird hier mit jedem Schleifendurchlauf auch ein neues Objekt/Instanz angelgt, die Variable "index" bekommt jetzt eine andere "neue" Referenz auf das neue Objekt/Instanz?

Eigentlich wird ja ein Objekt nur einmal angelegt, so wie ich das in der Literatur gelesen habe. Von diesem Objekt werden dann immer neue Instanzen gebildet. Jede Instanz kommt muss dann über eine Referenzvariable ansprechbar sein. Sehe ich das richtig?

Wenn ich aber wie in meinem Fall immer die gleich Variable verwende, habe ich ja quasi nur die Möglichkeit immer nur auf die letzte Instanz zu zugreifen, weil ja die alten Referenzvariablen immer wieder überschrieben werden, außer ich speicher die noch irgendwo zwischen. Sehe ich das auch so richtig?

Danke für deine Gedult!

mfg
Reen

 

[SlaterB]

> ODER wird hier mit jedem Schleifendurchlauf auch ein neues
> Objekt/Instanz angelgt, die Variable "index" bekommt jetzt
> eine andere "neue" Referenz auf das neue Objekt/Instanz?

richtig

> Von diesem Objekt werden dann immer neue Instanzen gebildet.

nicht richtig, Objekt und Instanz sind das gleiche

> Wenn ich aber wie in meinem Fall immer die gleich Variable verwende, habe ich ja quasi nur die Möglichkeit immer nur auf die letzte Instanz zu zugreifen, weil ja die alten Referenzvariablen immer wieder überschrieben werden, außer ich speicher die noch irgendwo zwischen. Sehe ich das auch so richtig?

klingt wieder richtig

 

[Reen]

Servus SlaterB

Jetzt habe ich aber das Prob., dass ich nich nur auch das letzte Objekt zugreifen möchte, sondern auf alle. Also kommt das jetzt ins Spiel, was ich oben schon meinte. Ich muss irgendwie die Referenzvariablen der einzelnen Objekte zwischenspeichern bzw. jeweil immer einen neuen Variablenname für das Objekt ArrayList erstellen.

Hast du ne Idee, wie ich das am besten anstellen kann? einfach "byte[] index[] = new byte[7]" über der Schleife klappt so nicht. Dann denkt der, es wird ein zweidimensionales Array draus.

danke
Reen

 

[SlaterB]

byte[] index[] sowieso nicht,
wenn dann schreibe "byte[][] index

-------

so, und wie man speichert ist dir doch grundsätzlich bekannt?
entweder in einem Array oder einer ArrayList oder ähnlichen Behältern, z.B. Kette
was geht nicht?

wenn du jetzt sagst, dass du Abspeicherung allgemein nicht kennst,
dann erzähle ich dir das nicht, das erzählt dir ein Buch,

und das testet man auch mit einfachen int-Variablen,
nicht mit Arrays in Arrays, das verwirrt nur unnötig

 

[Reen]

Oki...das werde ich dann morgen gleich mal versuchen.

Was mir aber gerade noch einfällt. Ist es vllt nicht einfacher, wenn ich z.B. am Listenelement 10 (angenommen ich habe 20 Einträge) was verändern möchte, aus dem Inhalt von LE 10 ein neues Objekt zu erstellen, da meine Veränderungen vornehme und dann in LE 10 das alte Objekt damit überschreibe.
Das wäre doch eigentlich die eindeutig bessere Lösung, als sich alle Referenzvariablen zu merken. Ginge das auch??

thx
Reen

 

[SlaterB]

was ist denn das für eine Logik?
1.
wenn du irgendwas in einer Liste an Position 10 hast,
wozu dann noch an andere Stelle speichern?

2.
wenn du Listenelement 10 hast, um was daraus zu erstellen und dann wieder an Position 10 zu speichern,
warum arbeitest du dann nicht direkt mit dem Objekt auf Position 10?

 

[Reen]

OKi...überzeugt

 

[Reen]

Hallo SlaterB

Habe jetzt mal eine Lösung gefunden, wie es zumindest funt

Object ref[] = new Object[100000];


for (i=0; i<5; i++)
 {	
     byte[] index = new byte[7];
     ref[i] = index;

     System.out.println(ref[i]);
}

Was ich nur nich so recht nachvollziehen kann, warum es nur mit dem Typ Objekt geht. Mir ist klar, dass alle Klassen und so weiter Unterklassen von Objekt sind. Aber eigentlich speichere ich ja quasi nur primitive Referenzvariablen und keine Objekte. Oder sehe ich das falsch?

Anderes Prob. ist ja, dass ich hier wiederrum eine feste Größe eintragen muss. Kann man das auch dynamischer machen?

thx
Reen

 

[SlaterB]

> eigentlich speichere ich ja quasi nur primitive Referenzvariablen und keine Objekte.

tja, das kann man sehen wie man es will,
denn genauso eigentlich ist das Array ja nicht für Objekte gedacht, sondern nur für primitive Referenzen darauf,

im Arbeitsspeicher wirst du ein 400000 Byte langes Objekt haben,
mit 100000x 4 Bytes für 100000 Referenzen,
die Objekte selber bleiben auf ihren Ursprungsplätzen verteilt im Speicher,

du könntest auch das riesige ref-Array selber an allen 100000 Stellen im Array eintragen,
es geht immer nur um Referenzen..

--------

statt
Object ref[] = new Object[100000];
könntest du auch
byte[][] ref = new byte[100000][];
verwenden

dynamischer mit deiner komischen Kette oder einer ArrayList,
ist das denn nicht offensichtlich?
List<byte[]> ref = new ArrayList<byte[]>(10000);