ArrayList initialisieren

[Guest]

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]

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]

Ich muss an die frische Luft.. ;-)

Danke auf jeden Fall!

 

[Tobias]

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]

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]

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]

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]

Oops, die hab ich übersehen.

mpG
Tobias

 

[Guest]

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]

Suchst du vielleicht sowas ?
Arrays.asList()

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

 

[Gast]

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]

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]

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]

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]

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]

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]

Ist doch schön ...

 

[Guest]

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]

Vielleicht zeigst du uns die Array-Variante

 

[Guest]

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]

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

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]

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]

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]

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]

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.