# Arraylist einer Methode, gefüllt einer anderen Klasse übergeben



## Angsthase (1. Okt 2012)

Huhu liebe Community!

Ich bin derzeit fleißig am Javalernen und bin nun gut 2 Monate dabei mir die ganzen Basics in den Hinterkopf zu prügeln! 

Momentan spiele ich etwas mit der ArrayList rum da es ja ein sehr mächtiges und Dynamisches "Array" sein soll.

Aber zu meiner Frage:

Wie schaffe ich es die ArrayList welche durch Methode A ind Klasse A befüllt wird, in Klasse B zur Methode B zu bringen? Habs teilweise mit Getter Setter probiert.. haut aber allers nicht so ganz hin :/

Ich denke ich kann auf das Arraylist nicht zugreifen weil es noch irgendwie in der Methode steckt..

Aber hier mal der Code zur Verdeutlichung:


```
import java.util.ArrayList;


public class Arraylistuebergabe {

	public static Arraylistuebergabe arraylist;

	private void ArrayinArraylist () {
		int[] array = new int [3];
		array[0] = 1;
		array[1] = 2;
		array[2] = 3;
		
		ArrayList<Integer> arraylist = new ArrayList<Integer>();
		arraylist.add(array[0]);
		arraylist.add(array[1]);
		arraylist.add(array[2]);
		int arraylistsize = arraylist.size();	
	}
	
		

}


class Arraylistnutzen {
	// Hier sollte das Array irgendwie hinein
	
	Arraylistuebergabe arraylist2 = Arraylistuebergabe.arraylist;
	
	public void verarbeiten() {
		
			System.out.print(arraylist2.indexOf(1));
		
	}
	
}
```

Es wäre Super wenn mir Jemand den Codeschnippsel verraten könnte, den ich vergessen habe. Bzw es in Doofy warten erklären könnte!

Vielen vielen Dank im Vorraus und bin auch echt froh das ich so ein aktives Forum gefunden habe!

lg


----------



## ARadauer (1. Okt 2012)

hier überschreibst du dir 
ArrayList<Integer> arraylist = new ArrayList<Integer>();
die lokale varialbe und veränderst diese nicht

lass das  ArrayList<Integer> weg dann sollte es klappen


----------



## ssoul26 (1. Okt 2012)

Wo wird denn die Methode ArrayinArraylist  aufgerufen??


----------



## ARadauer (1. Okt 2012)

stimmt hab ich gar nicht gesehen...


```
import java.util.ArrayList;
 
public class Arraylistuebergabe {
 
    public Arraylistuebergabe arraylist; //nix static
 
    private void ArrayinArraylist () {
        int[] array = new int [3];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        
        ArrayList<Integer> arraylist = new ArrayList<Integer>();
        arraylist.add(array[0]);
        arraylist.add(array[1]);
        arraylist.add(array[2]);
        int arraylistsize = arraylist.size();   
    }
    
        
 
}
 
class Arraylistnutzen {
    // Hier sollte das Array irgendwie hinein
    
    Arraylistuebergabe arraylist2 = new Arraylistuebergabe(); //neues objekt..
    
    public void verarbeiten() {
        
            System.out.print(arraylist2.indexOf(1));
        
    }
    
}
```


----------



## ssoul26 (1. Okt 2012)

Du musst erstmal das Objekt initialisieren und dann hast du -in deinem Fall- "problemlosen" Zugriff drauf. Verwende dafür die Methode ArrayinArraylist, entweder privat oder testweise public.


----------



## Angsthase (2. Okt 2012)

heyhey! Ich bin euch sehr dankbar für die schnellen Antworten.

Hab den Quelltext nun etwas abgeändert und zusätzlich noch eine Mainmethode zur Ausführung dieser beiden Methoden erstellt.

Leider bekomme ich bei der Überprüfung immernoch kein Element übermittelt, sondern nur den Wert "0".

Hier der neue Quelltext:


```
import java.util.ArrayList;

public class Arrraylistuebergabe {

	public static void main(String[] args) {		
		// Objekt zur Erstellung des Arraylists
		Arraylisterstellen kraft = new Arraylisterstellen();
		kraft.ArrayinArraylist();
		
		// Objekt zur Überprüfung ob das Arraylist richtig in die Klasse Arraylistnutzen übergeben wurde
		Arraylistnutzen kraft2 = new Arraylistnutzen();
		kraft2.verarbeiten();
	}
}

// 1. Hier wird das Arraylist erstellt
class Arraylisterstellen {
	 
	ArrayList<Integer> arraylist = new ArrayList<Integer>();
	int arraylistSize;
	int arraylistIndex;
	
    public void ArrayinArraylist () {
        int[] array = new int [3];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        
        arraylist.add(array[0]);
        arraylist.add(array[1]);
        arraylist.add(array[2]);
        
        arraylistSize = arraylist.size();
        arraylistIndex = arraylist.indexOf(1);
        
    }         
}
 
// 2. Hier soll die Arraylist von der Methode ArrayinArraylist übergeben werden und gleichzeitig zur Überprüfung
// ein Index und die Anzahl der gespeicherten Elemente ausgegeben werden
class Arraylistnutzen {
    
		Arraylisterstellen arraylist2 = new Arraylisterstellen(); 
		
    public void verarbeiten() {
    			
            System.out.println(arraylist2.arraylistSize);
            System.out.println(arraylist2.arraylistIndex);
        
    }   
}
```

Wäre super wenn jemand nochmal den Quellcode überfliegen könnte!

Vielen Dank schon mal wieder!


----------



## ARadauer (2. Okt 2012)

Arraylisterstellen, Arraylistnutzen .. Objekte sind Dinge also am Besten Nomen(Hauptwörter) und Methoden sind Verhalten, also am besten Verben (Tunwörter)...

Macht null sind, dass du nutzen und erstellen in zwei klassen zerteilst, darum funktionierts auch nicht.... wenn du verhalten in Klassen kapseln möchtest, musst du das Ding auf das das Verhalten angewendet wird zwischen den Klassen teilen, dass muss dann das selbe objekt sein... du hast in erstellen und nutzen zwei unterschiedliche objekte


----------



## SlaterB (2. Okt 2012)

das Arraylistnutzen-Objekt kraft2 erstellt sich intern ein Arraylisterstellen-Objekt arraylist2,
dies ist leicht einzusehen ein anderes Objekt als das Arraylisterstellen-Objekt kraft in der main,

wenn du in kraft etwas initialisierst dann interessiert arraylist2 das doch nicht, zwei unterschiedliche Objekte

Lösung:
du könntest kraft aus der main an kraft2 mitgeben, Parameter im Konstruktor, kein eigenes Arraylisterstellen-Objekt dort,

oder auf kraft in der main verzichten und nur arraylist2 in kraft2 weiter initialisieren

(Klassen- und Objektnamen kommen dir in diesen Sätzen komisch vor? -> besser benennen)


----------



## ssoul26 (2. Okt 2012)

Mach draus ein static dann sollte es gehen.


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


----------



## Angsthase (2. Okt 2012)

Danke! Ja ich werd mich zukünftig um eine bessere Namensvergebung bemühen 
Das gesamte Javapaket ist für mich momentan nur leider etwas schwer zu verstehen^^

Aber danke danke danke nochmal.  Es funktioniert nun auch, nur weiss ich nicht, ob der Code so richtig ist.
Den Wert von 3 bekomme ich nun allerdings ausgegeben.

Hier nochmal der Code. Das was ich verändert/ neu hinzugefügt habe, habe ich mit "// NEU" kommentiert.


```
import java.util.ArrayList;

public class Arrraylistuebergabe {

	public static void main(String[] args) {		
		// Objekt zur Erstellung des Arraylists
		Arraylisterstellen kraft = new Arraylisterstellen();
		kraft.ArrayinArraylist();
		int x = kraft.arraylistSize;// NEU
		
		// Objekt zur Überprüfung ob das Arraylist richtig in die Klasse Arraylistnutzen übergeben wurde
		Arraylistnutzen kraft2 = new Arraylistnutzen();
		kraft2.verarbeiten(x); // NEU
	}
}

// 1. Hier wird das Arraylist erstellt
class Arraylisterstellen {
	 
	ArrayList<Integer> arraylist = new ArrayList<Integer>();
	int arraylistSize;
	int arraylistIndex;
	
    public void ArrayinArraylist () {
        int[] array = new int [3];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        
        arraylist.add(array[0]);
        arraylist.add(array[1]);
        arraylist.add(array[2]);
        
        arraylistSize = arraylist.size();
        arraylistIndex = arraylist.indexOf(2);
        
    }         
}
 
// 2. Hier soll die Arraylist von der Methode ArrayinArraylist übergeben werden und gleichzeitig zur Überprüfung
// ein Index und die Anzahl der gespeicherten Elemente ausgegeben werden
class Arraylistnutzen {
    
		Arraylisterstellen arraylist2 = new Arraylisterstellen();
		int wertvonX;//NEU
		
    public void verarbeiten(int x) { //NEU
    		wertvonX = x;//NEU
            System.out.println(wertvonX);
            System.out.println(arraylist2.arraylistIndex);
        
    }   
}
```

Vllt könnt ihr mich auch allgemein mitteilen, was man an diesen Code noch verbessern könnte.
Ich habe mal etwas von einer Methode gelesen die das Array autoamtisch in eine Arraylist befüllt??

liebe grüße


----------



## cable545 (2. Okt 2012)

Hallo,

warum machst Du das ? 

```
arraylistSize = arraylist.size();
```

Da Du ja am ausprobieren bist, kann man Dir ja keine großen Tips geben, da zumindest ich nicht genau weiß was Du dir dabei gedacht hast. Aber eigentlich...
Sieht alles schön aus.

Die Klasse Arrays besitzt ne Methode asList(). Schau Dir die mal in der Java Doku an.
Ansonsten würde ich das so machen


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

int[] array = new int [3];
array[0] = 1;
array[1] = 2;
array[2] = 3;

for(int value : array)
{
    arraylist.add(value); 
}
```


----------



## Angsthase (2. Okt 2012)

Danke Cable545,

ja für sowas wie 

```
for(int value : array)
{
    arraylist.add(value); 
}
```

bin ich schon extrem dankbar. Das ist genau das, was ich gemeint habe


----------



## Angsthase (2. Okt 2012)

und schon wieder habe ich das nächste Problem beim rumprobieren mit der Arraylist

Es geht nun darum das ich nicht mehr einzelne Werte wie .size() oder .indexOf() in
einer anderen Klasse benötige(diese konnte ich ja einfach in einer Variable speichern und per Parameter übergeben), sondern die ganzen gespeicherten Elemente.

Ich habe schon einen kleinen Lösungsansatz, allerdings funktioniert dieser leider nur mit static, mit dem es auch funktionieren würde..

Hier der Codein der unteren Klasse habe ich zum Verständnis wieder alles ausreichend kommentiert)


```
import java.util.ArrayList;

public class Arrraylistuebergabe {

	public static void main(String[] args) {		
		// Objekt zur Erstellung des Arraylists
		Arraylisterstellen kraft = new Arraylisterstellen();
		kraft.ArrayinArraylist();
		int x = kraft.arraylistSize;
		
		
		// Objekt zur Überprüfung ob das Arraylist richtig in die Klasse Arraylistnutzen übergeben wurde
		Arraylistnutzen kraft2 = new Arraylistnutzen();
		kraft2.verarbeiten(x); 
		kraft2.verarbeiten2(x);
		
	}
}

// 1. Hier wird das Arraylist erstellt
class Arraylisterstellen {
	 
	ArrayList<Integer> arraylist = new ArrayList<Integer>(); // hier müsste das unten im Kommentar erwähnte static gesetzt werden
	int arraylistSize;
	int arraylistIndex;
	
    public void ArrayinArraylist () {
        int[] array = new int [3];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        
        for(int value : array)
        {
            arraylist.add(value); 
        }
        
        arraylistSize = arraylist.size();
        arraylistIndex = arraylist.indexOf(2);
    }     
    private ArrayList<Integer> arraylist() {
		return arraylist;
	}
}
 
// 2. Hier soll die Arraylist von der Methode ArrayinArraylist übergeben werden 
class Arraylistnutzen {
    		
	int wertvonX;		
    public void verarbeiten(int x) { 
    		wertvonX = x;
            System.out.println(wertvonX);    
    }
    
    
    // ***Ab hier soll die Abfrage des gesamten(alle Elemente) übergebenen Arraylist stattfinden
    //    und zum Test eine kleine Schleife die die vorhandenen Elemente nach und nach löscht
    
    ArrayList<Integer> arraylist2 = Arraylisterstellen.arraylist; // hier scheiterts wieder irgendwie weil ich nicht weiss wie der Code genau geschrieben wird O.o würde ich
    															  //  oben bei ArrayList<Integer> arraylist = new ArrayList<Integer>(); static vorne dran setzen funktioniert es
    															  // aber das wäre ja nicht der richtige Lösungsweg. Nun, wie müsste ich es schreiben?
    
    int Elementnummer; 
    int Counter = 3;
  
    public void verarbeiten2(int x) {
    	Elementnummer = x;
    	while (Counter > 0) {    	
	    		arraylist2.remove(Elementnummer-1); //// - 1 da die Arraylist ja von Index 0 beginnt
	    		Elementnummer--;
	    		Counter--;
	    		System.out.println("Es sind noch " + Elementnummer + " Elemente im arraylist2");	    	
    	}
    }
	
}
```

es wäre super wenn mir jemand den fehlenden Codeschnipsel ergänzen könnte.
Habs auch mit einem getter versucht. Leider vergebens bzw höchstwahrscheinlich falsch.

Danke wieder!!


----------



## ARadauer (2. Okt 2012)

ssoul26 hat gesagt.:


> Mach draus ein static dann sollte es gehen.
> 
> 
> ```
> ...



:autsch: genau das ist der falsche weg. static sollte man meiner meinung nach nur verwenden, wenn man es auch static machen will


----------



## ARadauer (2. Okt 2012)

Galileo Computing :: Java ist auch eine Insel - 3 Klassen und Objekte


----------



## Angsthase (4. Okt 2012)

ja das Java objektorientiert ist, habe ich bereits bewusst im Hinterkopf gespeichert. Deswegen auch die Frage wie der Code aussehen müsste, damit ich dieses "static" umgehen kann?

Hänge momentan leider immernoch am Schlauch und weiss nicht wie ich der Quelltext aussehen müsste ;/


----------



## SlaterB (4. Okt 2012)

warum funktioniert
> System.out.println(wertvonX);

warum funktioniert
> arraylist2.remove(Elementnummer-1);

ohne dass die jeweiligen Variablen statisch sind 
und im Quellcode von ArrayList bzw. PrintStream statisch auf deine Klassen zugegriffen wird?
(*)

weil Objekte ÜBERGEBEN werden, Methoden und Konstruktoren können Parameter haben, X gibt Y an Z weiter,
denke dazu nach und hinterfrage nochmal deinen Hinterkopf, was genau er von 'objektorientiert' schon verstanden hat 

bewußt vorerst keinen Code, das ist eines der wichtigsten Grundlagenthemen die du zwingend durchdringen musst


--------

edit:
(*)
bzw. mit
> kraft2.verarbeiten(x);
usw. machst du doch aus selber schon gut Übergaben,
wieso kannst du x nicht statisch weitergeben, die Liste aber nicht?
sind doch alles nur Objekte bzw. primitive Werte, alles gleich auszutauschen,
setArrayList() oder was auch immer, Konstruktor im Parameter


----------



## sdsdfsdf (4. Okt 2012)

Guten morgen,

wieso machst du nicht einfach eine Klasse die einen Arraylist erstellst und schreibst dann in die selbe Klasse Methoden, die es ermöglichen, Elemente in die Liste zu schieben, zu löschen bzw aufzurufen. Diese kannst du dann in der Klasse deiner Wahl aufrufen und damit arbeiten. 

Ich würde es so lösen: 


```
package arrayListe;

import java.util.ArrayList;
import java.util.Iterator;

public class ZugriffAufArrayList {

	ArrayList<Integer> zahlenListe = new ArrayList<Integer>();
	
	//Added ausgewähltes Element
	public void addElement(Integer x){
		zahlenListe.add(x);
		System.out.println(x+ " Wurde erfolgreich hinzugefügt");
		
	}
	
	//Löscht Element x in der Arraylist
	public void deleteElement(int index){
		zahlenListe.remove(index);
		
	}
	
	
	//Return die ArrayList
	public ArrayList<Integer> getArrayList(){
		
		return zahlenListe;
	}
	
	
	//Liefter die Größe der ArrayList
	
	public int getSize(){
		
		return zahlenListe.size();
	}
	//Gibt die momentanen Werte zurück
	public void werteDerArryList(){
		int zaehler = 0;
		if(zahlenListe.size()!= 0){
			
			for (Iterator<Integer> iterator = zahlenListe.iterator(); iterator.hasNext();) {
				Integer jetztigerIntegerWert = (Integer) iterator.next();
				
				System.out.println("Daten im Fach: "+ zaehler +" Wert: " +jetztigerIntegerWert +"");
				zaehler++;
			}
			
		}
		
		
	}
	
	
	
	
	
	
	
	
	
}
```



```
package arrayListe;

public class DemoZugriffAufArrayListe {

	
	
	
	
	
	public void run(){
		
		
		//Es wird ein neues Objekt gebaut.
		ZugriffAufArrayList neueArrayListe = new ZugriffAufArrayList();	
		
		neueArrayListe.addElement(10);
		neueArrayListe.addElement(30);
		neueArrayListe.addElement(12321);
	
		neueArrayListe.werteDerArryList();
		
		neueArrayListe.deleteElement(1);
		
		System.out.println("Nach löschung des Faches 1:");
		
		neueArrayListe.werteDerArryList();
		
		
		/*
		 * Die Daten in der ArrayList sind jetzt nur in unserer Demo vorhande
		 * Wenn man jetzt eine andere Klasse hat und ein neues Objekt hat, 
		 * hat man natürlich auch nicht mehr die selben Werte. 
		 */
		
		
	}
	
	public static void main(String[] args) {
	
	DemoZugriffAufArrayListe demo = new DemoZugriffAufArrayListe();
	demo.run();
		
		

	}

}
```


----------

