# ArrayList initialisieren



## Guest (27. Okt 2007)

Hi,  ich moechte an stelle eines Array eine ArrayList nutzen, da sie mir fuer den weiteren Verlauf des Programmes mehr bringt.
Nun habe ich aber schon Probleme diese zu intialisieren. Und zwar soll sie eine Laenge von 20 haben, und der jeder Platz in der ArrayList mit 10 initialisiert werden.


```
public ArrayList<Integer> arrayList = new ArrayList<Integer>();

for (int i = 0; i < 20; i++) {
			i = 10;
			arrayList.add(new Integer(i));
}
```

Es folgt ein Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

Ich habe mir das ganze relativ äquivalent vorgestellt.. Was mache ich falsch?

VG


----------



## Tobias (27. Okt 2007)

Dadurch das du die Schleifenvariable i jedesmal mit 10 überschreibst, wird deine Schleife nie beendet - bis halt der Platz im Speicher ausgeht.

Mach sowas:


```
ArrayList<Integer> arrayList = new ArrayList<Integer>();

for (int i = 0; i < 20; i++) {
         arrayList.add(10);
}
```

mpG
Tobias


----------



## Gast (27. Okt 2007)

Ich muss an die frische Luft.. ;-)

Danke auf jeden Fall!


----------



## Tobias (27. Okt 2007)

Du kannst einer ArrayLIst übrigens mit ihrem Konstruktor ArrayList(int initialCapacity) mitteilen, wie groß sie sich am Anfang dimensionieren soll. Das erspart dir in deinem Fall ein paar resize-Operationen und damit ein paar Milisekunden Programmlaufzeit.

mpG
Tobias


----------



## Gast (27. Okt 2007)

Die frische Luft muss doch noch was warten.. Noch ist die Umstellung nicht vollendet bzw funktioniert nicht alles so wie es soll. Ich vermute es liegt an folgender Problematik:
Ich hatte mein Array hochzaehlen lassen, also array[index]++..
In der ArrayList habe ich es wie folgt implementiert: arrayList.listIterator(index ++);

Gibt es da eine andere Moeglichkeit, oder ist das schon korrekt so?


----------



## Tobias (27. Okt 2007)

Das geht so nicht. Den die ArrayList gibt dir ein immutable Integer-Objekt zurück, sprich, du kannst den Inhalt der ArrayList nicht verändern, ohne ihre add()-Methode zu verwenden. So sollte es gehen:


```
int element = arrayList.get(index);
arrayList.remove(index);
arrayList.add(index, element + 1);
```

Nicht getestet, aber es sollte dir zumindest ein Gefühl für das Notwendige geben...

mpG
Tobias


----------



## Wildcard (27. Okt 2007)

Tobias hat gesagt.:
			
		

> du kannst den Inhalt der ArrayList nicht verändern, ohne ihre add()-Methode zu verwenden.


AUch wenn man sich meint sicher zu sein, ein Blick in die API schadet nicht...
http://java.sun.com/javase/6/docs/api/java/util/List.html#set(int, E)


----------



## Tobias (27. Okt 2007)

Oops, die hab ich übersehen.

mpG
Tobias


----------



## Guest (28. Okt 2007)

Ich habe nach wie vor nicht mein Array in eine ArrayList umgesetzt bekommen bzw ein aequivalentes Verhalten erzeugen können. Warscheinlich ein Verständnisproblem...


```
public void start(int listenIndexNummer){
		int index = listenIndexNummer ;
		int temp = list.get(index);
		
		while (index != 0){
			list.add(index, temp +1);
			index--;
		}
	}
```

Die Variable listenIndexNummer bekommt einen Wert zugewiesen der auf eine Postion in der Liste zeigt. Der Inhalt dieser Position soll auf die anderen Postionen veteilt werden. Das klappt auch wunderbar beim ersten Mal. Nur beim zweiten Aufruf dieser Methode zählt die Liste nicht nur ba der übergebenen LsitenIndexNummer, sondern auch noch irgendwo mittendrin hoch..

Wer kann mir da nochmal weiterhelfen?


----------



## HLX (28. Okt 2007)

Suchst du vielleicht sowas ? 
Arrays.asList()

Funktioniert allerdings nicht bei Arrays aus primitiven Datentypen (zumindest unter 1.5).


----------



## Gast (29. Okt 2007)

Nein.. Wie geschrieben, wird die Funktion eigentlich erfüllt. 
Nur wenn ich z.B. beim ersten Aufruf von Start 7 übergebe, nimmt er sich die Menge 10 von Position 7 und zählt von 8 bis 17 hoch und addiert 1. Wenn ich nun aber z.B. die 0 übergebe fängt er an Positon 1 an die Menge 10 hochzuzählen, aber halt auch irgendwo mitten in der Liste bzw setzt, die vorher gezählten wieder um 1 zurück..


----------



## Murray (29. Okt 2007)

Gast hat gesagt.:
			
		

> wenn ich z.B. beim ersten Aufruf von Start 7 übergebe, nimmt er sich die Menge 10 von Position 7 und zählt von 8 bis 17 hoch und addiert 1.


Nein. Wenn du 7 übergibst und an der Stelle 7 in der Liste eine 10 steht, dann zählt er von 7 bis 1 runter und fügt an der jeweiligen Position in der Liste ein neues Element mit dem Wert 11 ein. Verteilt wird da nichts, und die Liste ist hinterher 7 Elemente länger.


----------



## SlaterB (29. Okt 2007)

deine Beschreibungen und dein Code stimmen nicht überein,
du sprichst vom 'hochzählen', im Code steht index--

du sprichst vom Verteilen, was aber passiert, ist dass die immergleiche Zahl temp+1 mehrmals neu in die Liste eingefügt wird

(list.add(); fügt in die Liste ein und erhöht nicht vorhandene Werte oder ähnliche Späße)

was soll überhaupt passieren?
poste eine vollständige Liste vorher + nachher, 
idealerweise eine kurze Liste, nur wenige Elemente, nur Zahlen im Bereich 1-4 statt 10 wenn möglich,
vollständiger Code usw,
rede Klartext! 



```
class Test
{

    public static void main(String args[])
        throws Exception
    {
        KomischeListe l = new KomischeListe();
        System.out.println("Anfang: " + l);
        l.start(3);
        System.out.println("End   : " + l);
    }
}


class KomischeListe
{
    List<Integer> list;

    public KomischeListe()
    {
        int anz = 6;
        list = new ArrayList<Integer>(anz);
        for (int i = 0; i < anz; i++)
        {
            list.add(10);
        }
    }

    public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list.get(index);

        while (index != 0)
        {
            list.add(index, temp + 1);
            index--;
        }
    }

    public String toString()
    {
        return "KL: "+list.toString();
    }

}

-> Ausgabe:

Anfang: KL: [10, 10, 10, 10, 10, 10]
End   : KL: [10, 11, 10, 11, 10, 11, 10, 10, 10]
```


----------



## Guest (29. Okt 2007)

Ok, habt ja recht.. Bleiben wir mal beim Beispiel KomischeListe...
 Ich habe zunächst die Methode list.add(); falsch angewandt. Meine direkt Frage ist, wie kann ich die Werte verändern, so dass ich nur die initialisierten Werte 0 - 5 mit dem Wert 10 bearbeite?

Die Methode start() würde natürlich so mehr Sinn ergeben.:
Nur was kann man für add() einsetzen?

```
public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list.get(index);

        while (temp != 0)
        {
            index++
            list.add(index, temp + 1);
            temp--;
        }
    }
```


----------



## SlaterB (29. Okt 2007)

z.B.


```
public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list.get(index);

        while (temp != 0)
        {
            index++;
            list.set(index, list.get(index) + 1);
            temp--;

        }
    }
```
in einem int[] wärs leicht(er):
array[index]++;


----------



## Gast (29. Okt 2007)

Hi,
ein int[] war meine Ausgangssituation. Nun wollte ich das mit einer ArrayList gestaltet, weil ich damit später flexibler bin, und diese insgesamt schneller ist.

Das Beispiel bringt mir leider ein relativ gleiches Ergebnis wie vorher.


----------



## The_S (29. Okt 2007)

Ist doch schön ...


----------



## Guest (29. Okt 2007)

Ich meine das selbe Ergebnis wie in diesem Beispiel..


```
public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list.get(index);

        while (temp != 0)
        {
            index++
            list.add(index, temp + 1);
            temp--;
        }
    }
```

Schön wäre es erst, wenn das Ergebnis zur Array-Variante gleich wird... ;-)[/quote]


----------



## Murray (29. Okt 2007)

Vielleicht zeigst du uns die Array-Variante


----------



## Guest (29. Okt 2007)

Die Variante sah so aus...

```
public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list[listenIndexNummer];

        while (temp != 0)
        {
            index++
            list[index]++;
            temp--;
        }
    }
```


----------



## SlaterB (29. Okt 2007)

> Das Beispiel bringt mir leider ein relativ gleiches Ergebnis wie vorher.

mit solch hohlen Gerede kommt man nicht weiter,
ich habe dir schon einmal gesagt: gib E X A K T E Beispiele, was passiert und was stattdessen passieren soll,

bei mir siehts derzeit so aus:


```
public class Test
{
    public static void main(String args[])
        throws Exception
    {
        KomischeListe l = new KomischeListe();
        System.out.println("Anfang: " + l);
        l.start(3);
        System.out.println("End   : " + l);
    }
}


class KomischeListe
{
    List<Integer> list;

    public KomischeListe()
    {
        int anz = 8;
        list = new ArrayList<Integer>(anz);
        for (int i = 0; i < anz; i++)
        {
            list.add(4);
        }
    }

    public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list.get(index);

        while (temp != 0)
        {
            index++;
            list.set(index, list.get(index) + 1);
            temp--;

        }
    }

    public String toString()
    {
        return "KL: " + list.toString();
    }

}


-----

Ausgabe:

Anfang: KL: [4, 4, 4, 4, 4, 4, 4, 4]
End   : KL: [4, 4, 4, 4, 5, 5, 5, 5]
```

exakt was du haben willst (nachdem was ich bisher gelesen habe)

dass z.B. das verteilte Feld auf 0 gesetzt wird, fehlt natürlich noch,
das wirst du schon schaffen


----------



## Gast (29. Okt 2007)

Was gibt dir deine Liste aus wenn die Variable int listenIndexNummer beim nächsten Durchlauf der Liste z.B. 6 übergeben bekommt?
Es sollte folgendes passieren:
int listenIndexNummer = 3
Anfang: KL: [4, 4, 4, 4, 4, 4, 4, 4]
End   : KL: [4, 4, 4, 4, 5, 5, 5, 5] 
int listenIndexNummer = 3
Anfang  : KL: [4, 4, 4, 4, 5, 5, 5, 5] 
End   : KL: [5, 5, 5, 5, 5, 5, 5, 6] 

Das ist aber nicht der Fall für diese Liste, die auch als Beispiel nun so bearbeite..


----------



## SlaterB (29. Okt 2007)

na von selbst passiert sowas auch nicht, das ist doch ein ganz neues Verhalten, 

du willst also am Ende der Liste wieder auf den Index 0 springen,

ganz platt für dich hinschreibe werde ich es nicht,
du bist ja derjenige, der hier nachdenken soll 

mach dich mit der Modulo-Rechenoperation vertraut, die hilft hier,
ein einfaches if tuts natürlich auch


----------



## Gast (29. Okt 2007)

Freut mich, dass das schon weniger hohl war..
Dieses Feature will ich tatsächlich auch haben ,aber da werde ich mir noch Gedanken machen.
Aber zunächst nochmal zum zweiten Zug..
int listenIndexNummer = 3
Anfang: KL: [4, 4, 4, 4, 4, 4, 4, 4]
End : KL: [4, 4, 4, 4, 5, 5, 5, 5] 
int listenIndexNummer = 1
Anfang: KL: [4, 4, 4, 4, 4, 4, 4, 4]
End : KL: [4, 4, 5, 5, 6, 6, 5, 5] 

Bei mir erscheint folgendes End:
KL: [4, 4, 5, 5, 5, 5, 4, 5]


----------



## SlaterB (29. Okt 2007)

was ich wiederum nicht nachvollziehen kann,
grenzt schon an Hohlheit 


```
public class Test
{
    public static void main(String args[])
        throws Exception
    {
        KomischeListe l = new KomischeListe();
        System.out.println("Anfang: " + l);
        l.start(3);
        System.out.println("Mitte : " + l);
        l.start(1);
        System.out.println("End   : " + l);
    }
}


class KomischeListe
{
    List<Integer> list;

    public KomischeListe()
    {
        int anz = 8;
        list = new ArrayList<Integer>(anz);
        for (int i = 0; i < anz; i++)
        {
            list.add(4);
        }
    }

    public void start(int listenIndexNummer)
    {
        int index = listenIndexNummer;
        int temp = list.get(index);

        while (temp != 0)
        {
            index++;
            list.set(index, list.get(index) + 1);
            temp--;

        }
    }

    public String toString()
    {
        return "KL: " + list.toString();
    }

}

-----

Anfang: KL: [4, 4, 4, 4, 4, 4, 4, 4]
Mitte : KL: [4, 4, 4, 4, 5, 5, 5, 5]
End   : KL: [4, 4, 5, 5, 6, 6, 5, 5]
```


----------



## Gast (29. Okt 2007)

Ok, hast gewonnen. Ich bin hohl..
Danke dir!

Dann werde ich mal um den Sprung kümmern. Wenn du einen hilfreichen Link zur Hand hast, danke ich dir doppelt.


----------

