# Beschreibung von Code und Rückgabe von Anzahl in ArrayList



## Akkarin (20. Sep 2008)

Hallo Zusammen,

Wie man sieht, bin ich hier neu und denselben Status hab ich wohl auch in Sachen Java.
Wir müssen in der Schule ein Projekt schreiben, dass das Sammeln, Sortieren, Suchen und Ändern von Daten beinhaltet.

Folgender Code bekam ich vom Lehrer kurz mitgegeben:


```
private ArrayList<Einheit> sucheTyp(String typ)
    {
        ArrayList<Einheit> result = new ArrayList<Einheit>();
        for(Einheit a :einheiten)
        {
            if (typ.equals("Alpha"))
            result.add(a);
        }
        return result;
    }
```

Da ich noch immer recht starke Verständnisschwierigkeiten habe, wollte ich fragen, ob mir jemand erklären kann - Schritt für Schritt - was dieser Code genau macht? Ich schreibe hier auch gleich mal, was ich so verstehe (resp. denke zu verstehen):

Der Code macht eine ArrayList aus der Klasse Einheit namens sucheTyp
Die nächste Zeilen sind mir nicht ganz klar.

Bei der if-Abfrage kuckt er ob das Datenfeld typ den String "Alpha" beinhaltet und falls dem so ist, fügt er diesen Eintrag der Variable 'a' hinzu?

Am Schluss gibt er noch das result zurück.




Wenn ich jetzt eine Abfrage machen möchte, die mir z.B. die Anzahl an Einheiten "Alpha" angibt, wie kann ich dann dieses 'result' ansteuern?

Ich hab ja z.B. für die Gesamtliste (also wo auch Alpha, Beta, etc...) drin sind folgenden, einfachen Code:


```
public int anzahlTotal()
    {
      return einheiten.size();
    }
```

Jetzt muss ich ja aber irgendwie beim return das Resultat (der temp. Liste) von oben ansprechen. Ich weiss jetzt aber nicht so genau, wie ich das mache.

Vielleicht noch zum Verständnis:

Ich hab zwei Klassen. Die Hauptklasse Sammlung und die Klasse Einheit.

Sammlung------->Einheit

Und die obige Suchabfrage muss ich dann schlussendlich für 4 verschiedene Suchbegriffe erstellen.


----------



## diggaa1984 (20. Sep 2008)

ma kieken 


```
private ArrayList<Einheit> sucheTyp(String typ) {
```
eine private Methode, welche eine ArrayList (Elemente sind vom Typ Einheit) zurückgibt. Die Methode heisst "sucheType" und verlangt als übergebenen Wert einen Parameter vom Typ String. Aufruf also zB: _ArrayList<Einheit> neueListe = sucheTyp("Alpha");_



```
ArrayList<Einheit> result = new ArrayList<Einheit>();
```
erstellt eine neue lokale ArrayList namens "result", welche ebenfalls den Klassentyp Einheit von ihren Elementen fordert (wird also als Rückgabe-Referenz behandelt, daher auch result als ganz glückliche Wahl als Bezeichner ^^)



```
for(Einheit a :einheiten) {
    if (typ.equals("Alpha"))
        result.add(a);
}//for
        
return result;
```
in einer Schleife wird über das Feld (oder evt. auch ne Liste, is nicht sichtbar in dem Code), referenziert von der Variable "einheiten" iteriert, also jedes Element einmal "angefasst". 
Was nun n bissel unsinnig erscheint ... Wenn der übergebene Parameter "typ" mit der Zeichenkette "Alpha" übereinstimmt, so wird das grad aktuelle Element a (wie gesagt, die for-schleife betrachtet nacheinander alle Elemente aus "einheiten") der Ergebnis-ArrayList hinzugefügt. Am Ende wird diese ArrayList zurückgegeben

Es erscheint mir ein wenig wie das kopieren von "einheiten", wenn der Aufruf der Funktionzufällig mit dem richtigen String vollzogen wird.
Kannst du eventuell noch sagen, was genau "einheiten" darstellt? das muss irgendwo schon definiert worden sein.



> Jetzt muss ich ja aber irgendwie beim return das Resultat (der temp. Liste) von oben ansprechen. Ich weiss jetzt aber nicht so genau, wie ich das mache.



Mit dem obigen Funktionsaufruf hast du das Feld welches in der Methode "sucheTyp" erstellt und zurückgegeben wird, ausserhalb der Methode als "neueListe" verfügbar. Von dieser könntest du dann die Größe abfragen oder sonstige Sachen veranstalten.

Bitte erkläre nochmal genau was mit der Methode sucheTyp erreicht werden soll, laut Aufgabenstellung oder so ... der Sinn ist mir noch schleierhaft, sofern der Lehrer diese Struktur vorgegeben hat.


----------



## Akkarin (21. Sep 2008)

diggaa1984 hat gesagt.:
			
		

> Es erscheint mir ein wenig wie das kopieren von "einheiten", wenn der Aufruf der Funktionzufällig mit dem richtigen String vollzogen wird.
> Kannst du eventuell noch sagen, was genau "einheiten" darstellt? das muss irgendwo schon definiert worden sein.
> [/quote
> 
> ...


----------



## Akkarin (21. Sep 2008)

Ich merk grad dass ich da ja so eine Fehlermeldung zurückkriege:

eine NullpointerException:
null

Und das beim Erstellen der (Haupt-)Instanz. :S


----------



## diggaa1984 (21. Sep 2008)

Akkarin hat gesagt.:
			
		

> Ich muss eine Abfrage machen, resp. eine Liste erstellen, mit allen "Einheiten" (z.b. Autos) die vom Typ "xy" sind (z.b. Marke BMW) und dann deren Anzahl zurückgeben.



das is ja n kleiner unterschied .. entweder ne Liste erstellen, mit welcher du später noch arbeiten willst, oder einfach die Anzahl ermitteln. Dennoch geh ich nun davon aus, dass obige Methode von dir stammt, und nicht vom Lehrer, kannst du bitte mal bitte deine Klassen hier reinposten, denke das ist nicht allzuviel oder? dann kann man gleich schaun wegen der Exception.


----------



## Akkarin (21. Sep 2008)

Ja schon eher die Liste. Ich muss ja nachher noch andere Methoden zum suchen, anzeigen, entfernen, hinzufügen (hab ich ja schon) und sortieren erstellen.

hier mal der code:

"hauptklasse" (Sammlung)


```
import java.util.ArrayList;
import ch.zbw.hech2.importExport.CsvExporter;
import ch.zbw.hech2.importExport.CsvImporter;
import ch.zbw.hech2.importExport.Linie;

/**
 * 
 * 
 * @author Akkarin
 * @version 2008-09-19
 */
public class Sammlung
{    
    // Datenfeld für ArrayList Alphas
    private ArrayList<Einheit> einheiten;


    
    /**
     * Kostruiert eine neue Klasse für eine neue Sammlung
     */
    public Sammlung()
    {
        einheiten = new ArrayList<Einheit>();
    }

    /**
     * Diverse Methoden für die Verwaltung der Datenbank. Möglichst alle Methoden
     * über diese Hauptklasse steuern.
     */
    
    // setzt neue Alpha
    public void neueAlpha(String name, String art)
    {
        Einheit newEinheit = new Einheit(name, art, "Alpha");
        einheiten.add(newEinheit);
    } 
    
    // setzt neue Beta
    public void neueBeta(String name, String art)
    {
        Einheit newEinheit = new Einheit(name, art, "Beta");
        einheiten.add(newEinheit);
    }    

    
    // setzt neue Zeta
    public void neueZeta(String name, String art)
    {
        Einheit newEinheit = new Einheit(name, art, "Zeta");
        einheiten.add(newEinheit);
    }    


// setzt neue Omega
    public void neueOmega(String name, String art)
    {
        Einheit newEinheit = new Einheit(name, art, "Omega");
        einheiten.add(newEinheit);
    }    
    
    
    public void exportieren(){
        CsvExporter exporter = new CsvExporter();   
        
        Linie header = new Linie();
        header.add("Name");     // Name
        header.add("Art");      // Art
        header.add("Typ");      // Typ
        header.add("Alter");    // Alter
        
        exporter.add(header);
        
        for(Einheit einheit : einheiten){
            Linie linie = new Linie();
            linie.add(einheit.getName());    // linie.add(einheit.getName());
            linie.add(einheit.getArt());     // linie.add(einheit.getArt());
            linie.add(einheit.getTyp());     // linie.add(einheit.getTyp());
            linie.add(einheit.getAge());     // linie.add(einheit.age());

            exporter.add(linie);
        }
        
        exporter.writeToFile("einheiten.csv");
    } 
    
    
    public void importieren(){
        CsvImporter importer = new CsvImporter();   
        importer.readFromFile("einheiten.csv");
        Linie linie = importer.getNextLine();
        
        linie = importer.getNextLine();
        while(linie != null){

            Einheit newEinheit = new Einheit(linie.get(0), linie.get(1), linie.get(2), linie.getInt(3));
            einheiten.add(newEinheit);
            
            linie = importer.getNextLine();
        }
    }
    
    // Gibt die Gesamtzahl der Einheiten in der Sammlung zurück.
    public int anzahlTotal()
    {
      return einheiten.size();
    }
    

    // Gibt die Anzahl an Alphas zurück.
    

   
    private ArrayList<Einheit> sucheTyp(String typ)
    {
        ArrayList<Einheit> result = new ArrayList<Einheit>();
        for(Einheit a :einheiten)
        {
            if (typ.equals("Alpha"))
            result.add(a);
        }
        return result;
    }
    
    ArrayList<Einheit> neueListe = sucheTyp("Alpha");
    {
       
    }
```

und hier die untergeordnete klasse (Einheit):


```
public class Einheit
{

    private String name;  // Name der Einheit
    private String art;  // Art der Einheit
    private String typ;  //Typ, z.b. Alpha, Beta, Zeta, Omega, etc...
    private int age;     // Alter, in Tagen

    /**
     * Konstruktor setzt neue Einheit, bei der Name, Art und Typ eingegeben werden 
     * und das Alter auf 0 (Tage) gesetzt wird.
     */
    public Einheit(String name, String art, String typ)
    {
        // Alter auf Null setzen (in Tagen)
        this.name = name;
        this.art = art;
        this.typ = typ;
        this.age = 0;
    }
    
    
    /**
     * Konstruktor setzt neue Einheit, bei der Name, Art und Typ eingegeben werden 
     * und das Alter auf 0 (Tage) gesetzt wird.
     */
    public Einheit(String name, String art, String typ, int age)
    {
        // Alter auf Null setzen (in Tagen)
        this.name = name;
        this.art = art;
        this.typ = typ;
        this.age = age;
    }

    /**
     * Methoden die Name, Art, Typ und Alter der Einheit zurückgeben.
     * Benutzt für Import/Export ins csv.
     */
    
    public String getName(){
        return name;
    }
    
    public String getArt(){
        return art;
    }
    
    public String getTyp(){
        return typ;
    }
    
    public int getAge(){
        return age;
    }
    
}
```

Was den Code des Lehrers betrifft: es ist einfach ein Teil von ihm, ein Teil von mir. Aber um ehrlich zu sein, bin ich etwas überfordert mit dem ganzen Projekt.


----------

