# Funktion mehrere Rückgabewerte?



## magic_halli (22. Februar 2008)

Hi,

ich habe eine Funktion, die mir eine ArrayList zurückgibt. 

```
public ArrayList myFunction(){
   ArrayList myArrayList = new ArrayList();
   //hier meine Abarbeitung
   ...

   //wird zurückgeliefert
   return myArrayList;
}
```

Jetzt wäre es sinnvoll, wenn diese Funktion nach ihrer Abarbeitung mir 2 ArrayList´s zurückliefert!

```
public ArrayList myFunction(){
   ArrayList myArrayList = new ArrayList();
   ArrayList myNewArrayList = new ArrayList();
   //hier meine Abarbeitung
   ...

   //jetzt sollten irgendwie beide ArrayList´s zurückgegeben werden - wie?
   return ?;
}
```
Geht das? Wie kann ich das machen, wenns gehen sollte?

Danke und Gruß.


----------



## gora (22. Februar 2008)

Guten Morgen! 
Also . Zwei Werte als Return einer Funktion zurückzugeben ist nicht möglich!
Aber schriebe dir doch einfach kurz ein Objekt, dass als Eigenschaften deine 2 ArrayListen hat und gib dieses Objekt zurück.


```
public class meineDatenStruktur {

//Objekteigenschaften
private ArrayList myArrayList = new ArrayList();
private ArrayList myNewArrayList = new ArrayList();

//DefaultKonstruktor 
public meineDatenStruktur(){}

....
//hier noch Getter- und Setter - Methoden implementieren lassen (Macht ja  die IDE! ^^)
}
```


So ich glaube das müsste dir helfen ! 

Gruß Gora


----------



## zerix (22. Februar 2008)

Hallo,

du kannst es auch einfach so machen. Du übergibst einfach zwei ArrayLists, die nachher dann das Ergebnis beinhalten.


```
public void tuWas(ArrayList list1, ArrayList list2){

//abarbeitung
}
```

Das wird oft so gelöst.

MFG

Sascha


----------



## Thomas Darimont (22. Februar 2008)

Hallo,

nur um mal etwas über den Tellerrand zu schauen:
In C# realisiert man mehrere Rückgabewerte oft über explizite Referenzen:

```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace De.Tutorials.Training
{
    public class MultipleReturnValues
    {
        public static void Main(string[] args)
        {
            int a = 0; // wird verändert da by ref übergeben
            string b = null; // wird verändert da by ref übergeben
            int c = 666; // wird nicht verändert da by value übergeben
            object d = Foo(ref a, ref b, c );

            Console.WriteLine("a:{0}, b:{1}, c:{2}, d:{3}",a,b,c,d);
        }

        private static object Foo(ref int a, ref string b,int c)
        {
            a = 4711;
            b = "Test";
            c = 123;
            return new List<string>();
        }
    }
}
```

Ausgabe:

```
a:4711, b:Test, c:666, d:System.Collections.Generic.List`1[System.String]
Drücken Sie eine beliebige Taste . . .
```

Gruß Tom


----------



## magic_halli (22. Februar 2008)

Ok, ich hab das jetzt erstmal so gemacht...
Ich habe mir eine neues Objekt zu speichern zweier ArrayList´s gebaut:

```
public class MyArrayLists {

	private ArrayList alZwischenErg = new ArrayList();
	private ArrayList alBerechnet = new ArrayList();
	
	//Default Konstruktor
	public MyArrayLists (ArrayList alZwischenErg, ArrayList alBerechnet){
		
		this.alZwischenErg = alZwischenErg;
		this.alBerechnet = alZwischenErg;
		
	}

	//Getter zum zurückliefern der einzelnen ArrayList´s
	public ArrayList getAlBerechnet() {
		return alBerechnet;
	}

	public ArrayList getAlZwischenErg() {
		return alZwischenErg;
	}
	
}
```

So, im eigentlichen Programm in der Funktion, die die ArrayList´s erzeugt, speichere ich diese dann so in das Objekt: (ist das richtig so?)

```
public ArrayList myFunction(){
         ArrayList alZwischenErg = new ArrayList();
         ArrayList alBerechnet = new ArrayList();

         //hier meine Abarbeitung
         ...
         //speichern ins Objekt
         new MyArrayLists(alZwischenErg, alBerechnet);
}
```
Nur wie lese ich dann die beiden ArrayList´s an anderer Stelle im Hauptprogramm wieder aus, um sie jeweils einzeln wieder vorliegen zu haben?

Gruß


----------



## zeja (22. Februar 2008)

Wenn du dir in von myFunction das neue Objekt zurückgeben lässt, also den returnwert auf MyArrayLists  änderst kannst du doch mit deinen Gettern auf die einzelnen Listen zugreifen.


----------



## magic_halli (25. Februar 2008)

zeja hat gesagt.:


> Wenn du dir in von myFunction das neue Objekt zurückgeben lässt, also den returnwert auf MyArrayLists  änderst kannst du doch mit deinen Gettern auf die einzelnen Listen zugreifen.



In myFunction will ich die ArrayListen in das neue Objekt speichern Frage hierzu: Mache ich das syntaktisch richtig?

...und wie lese ich dann aber die ArrayListen aus dem Objekt wieder aus? (geschieht in einer anderen Funktion)

Gruß


----------



## zerix (25. Februar 2008)

```
public MyArrayLists myFunction(){
         ArrayList alZwischenErg = new ArrayList();
         ArrayList alBerechnet = new ArrayList();
          //hier meine Abarbeitung         ...        
 //speichern ins Objekt         
 return new MyArrayLists(alZwischenErg, alBerechnet);}
```

Jetzt bekommst du eine Object von MyArrayLists zurück. Da kannst du dann über die getter auf die Listen zugreifen.

Beispiel

```
MyArrayLists lists = new MyArrayLists(new ArrayList(), new ArrayList());

ArrayList  list = lists.getAlBerechnet();
```

MFG

Sascha


----------



## magic_halli (25. Februar 2008)

Ich habe das jetzt erstmal so umgesetzt und bekomme keine Fehler mehr. Allerdings sind meine ArrayListen im Hauptprogramm, wenn ich sie aus dem Object wieder auslese, leer
In der Funktion, wo die ArrayListen erstellt werden, enthalten sie Datensätze:

```
public MyArrayLists myFunction(){
   ArrayList alZwischenErg = new ArrayList();
   ArrayList alBerechnet = new ArrayList();
   //hier meine Abarbeitung        
   ...        
   //Testausgabe der ArrayList-Längen; sind korrekt!
   JOptionPane.showMessageDialog(null, "alZwischenErg-size="+alZwischenErg.size()+"    alBerechnet.size="+alBerechnet.size());

   //speichern ins Objekt und zurückgeben
   return new MyArrayLists(alZwischenErg, alBerechnet);}
}
```
Im Hauptprogramm lese ich die ArrayListen so aus:

```
...
ArrayList alBerechnet = new ArrayList();
ArrayList alZwischenErg = new ArrayList();
...
myFunction();
MyArrayLists lists = new MyArrayLists( new ArrayList(), new ArrayList() );
alZwischenErg = lists.get_alZwischenErg();
alBerechnet = lists.get_alBerechnet();

//Testausgabe: beide ArrayList´s zeigen Länge=0 an?! Warum nur?
JOptionPane.showMessageDialog(null, "alZischenErg-size="+alZwischenErg.size()+"   alBerechnet-size="+alBerechnet.size());
```
Beim auslesen der ArrayListen im Hauptprogramm haben diese allerdings plötzlich die Länge 0, also sind leer, obwohl sie beim speichern in myFunction() noch gefüllt waren!
Hab ich hier was falsch gemacht bzw. lösche ich die ArrayListen hier irgendwie?


----------



## gora (25. Februar 2008)

Moinsen!
Ja da hast du noch ein paar Kleinigkeiten verdreht würde ich mal sagen :

deine Funktion  myFunktion(); liefert dir doch einen Return und zwar dein MyArrayLists-Objekt. warum benutzt du das nicht ? Da koennten naemlich auch die richtigen Werte drinstehen. ^^



```
...
ArrayList alBerechnet = new ArrayList();
ArrayList alZwischenErg = new ArrayList();
...
//Speichern des Returns von myFunction() in dem Objekt lists ! 
MyArrayLists lists = myFunction();
alZwischenErg = lists.get_alZwischenErg();
alBerechnet = lists.get_alBerechnet();


JOptionPane.showMessageDialog(null, "alZischenErg-size="+alZwischenErg.size()+"   alBerechnet-size="+alBerechnet.size());
```

Ich habe es zwar nicht getestet. Sollte aber klappen ! 

Gruß Gora


----------



## magic_halli (25. Februar 2008)

Juhu, es klappt 

@gora: Das war genau die Sache, die ich wohl schlichtweg übersehen hatte?! Jetzt t es endlich.

Danke und Gruß


----------

