# ArrayList



## fiber (7. Nov 2014)

Hallo,

folgende Aufgabe ist gegeben:

Schreiben Sie eine Methode, die mithilfe der Methode *get*das fünfte Objekt in einer Sammlung mit den Namen *elemente* liefert.

Meine Lösung:

```
public void getElement()
    {
        ELement element = new ArrayList<>(elemente);
        element.add(elementname);
        System.out.println(element.get(index(4));
        
    }
```


----------



## Thallius (7. Nov 2014)

Du steckst ein Element rein und willst das fünfte herausholen....

Und überhaupt was ist elementname?

Gruß

Claus


----------



## fiber (7. Nov 2014)

hab da einiges durcheinander geworfen schätze ich.

elementname sollte eigentlich *elemente* sein.
das fünfte Objekt ist doch index(4) ?
Was ist denn falsch? die komplette Implementierung?


----------



## Gucky (7. Nov 2014)

Ich sage es nicht gerne aber bei der Implementierung rollen sich mir die Zehennägel auf.
Da ist noch viel Potential nach oben.


```
ELement element = new ArrayList<>(elemente);
```
In der Zeile versuchst du einer Variable vom Typ Element eine neue ArrayList zuzuweisen. Das geht schon mal nicht, es sei denn Element erweitert ArrayList, was ich nicht glaube (extends Schlüsselwort. Kommt später  ).
Dann übergibst du der ArrayList eine Variable elemente, die es nicht gibt.
Im Diamantoperator <> muss ein Klassen- oder Interfacename stehen, da eine ArrayList generisch ist. D. h. sie passt sich den Klassen im Diamantoperator an.



```
element.add(elementname);
```
In der Zeile rufst du die Methode add auf die Variable element auf. Syntaktisch kein Problem, allerdings meinst du wahrscheinlich die ArrayList (siehe oben). Die Variable elementname gibt es nicht.


```
System.out.println(element.get(index(4));
```
Dort rufst du die Methode index auf, übergibst ihr den Wert 4 und den Rückgabewert übergibst du an die Methode get, die du auf element aufrufst. Die Rückgabe von element.get gibst du an System.out.println() weiter. Syntaktisch wieder kein Problem, allerdings gibt es keine Methode index (du meinst zwar den Index 4 aber dann musst du nur die 4 schreiben). Die Methode get ist vermutlich wieder die der ArrayList. Der Aufruf von System.out.println() ist kein Problem.



Ich möchte dich nicht desillusionieren und dich schlecht machen sondern dir nur aufzeigen, was an deinem Code falsch ist und das da noch ganz viel Verbesserungspotential ist. Denn an der Art, wie du gefragt hast, meine ich zu erkennen, das du weder dumm bist, noch versuchst uns auszunutzen sondern wirklich Java lernen willst.


----------



## fiber (7. Nov 2014)

Bin sehr Dankbar für die ausführliche Erklärung! Natürlich möchte ich Java lernen. Ich werde versuchen die Aufgabe zu lösen und dann poste ich meine neue Lösung.


----------



## fiber (8. Nov 2014)

BlueJ hat comlpiliert, Aber ob das auch richtig ist..?


```
import java.util.ArrayList;

public class Element
{
    private ArrayList<String> element;
    
    public Element()
    {
       
    }
    
    public void elementAusgeben(int index)
    {
       element.get(index); // Liefert das Objekt(?)
    }
}
```


----------



## fiber (8. Nov 2014)

wollte noch was dazu sagen. Ich habe die Aufgabe so verstanden, dass *element* die Sammlung in der ArrayList ist und das ich eine Methode mit Hilfe der *get* Methode schreiben soll, die aus der Sammlung *element* das fünfte Objekt liefert


----------



## Flown (8. Nov 2014)

Ist das wirklich Wort für Wort die Aufgabenstellung? Wenn ja, dann ist das eines der schlechtesten Lehrbücher die ich je gesehen habe!

Kannst du bitte, falls es wirklich nicht der richtige Wortlaut ist, die ganze Aufgabe nochmal hier reinschreiben? Was bis jetzt durchgenommen wurde (Collections, Generics, Arrays, Interfaces, Abstrakte Typen ... eben alles)


----------



## Gucky (8. Nov 2014)

Einfach nur element.get(int) aufzurufen bringt nichts. Genausogut könntest du auch einen Ball ins Meer werfen. Niemand ist da, der etwas dmait anfangen könnte.
return element.get(int) nimmt den Ball (der Rückgabewert von ArrayList#get(int)) und gibt ihn weiter an den Aufrufer von elementAusgeben(int).


Ließ dir doch bitte noch einmal genau die Aufgabenstellung und die vorherigen Kapizel des Buches durch.
Welches ist das überhaupt?


----------



## fiber (8. Nov 2014)

Das Buch ist von David J. Barnes, Michael Kölling. heißt „Java lernen mit BueJ“- Einführung in die OOP (5. Auflage)

In Kapitel 1: Objekte, Klassen, Methoden, Parameter

Kapitel 2 : Datenfeld, Konstruktor , Kommentar, Parameter, Zuweisung (=), Block, return, void, zusammengesetzter Zuweisungsoperator ( +=, -=), if

Kapitel 3 : Klassen als Typen, logische Operatoren (&&, ||), Verkettung von Zeichenketten, Modulo-Operator(%), Objekterzeugung (new), Methodenaufrufe (Punkt-Notation), this

Kapitel 4 : ArrayList, Iterator, While-Schleife, null, anonyme Objekte Arrays, for-Schleife, for-each-Schleife, ++

Bin gerade bei Kapitel 4 : Objektsammlungen - generische Klassen dran.
Dazu folgende Aufgaben( die ich gelöst habe):

Übung 4.4:
Schreiben sie die Deklaration eines privaten Datenfeldes bibliothek, das eine ArrayList halten kann. Die Elemente ArrayList sollen vom Typ Buch sein.

```
private ArrayList<Buch> bibliothek;
```
Übung 4.5:
Schreiben Sie die Deklaration einer lokalen Variable cs101, die eine ArrayList von Student-Objekten hält.

```
ArrayList<Student> cs101;
```
Übung 4.6:
Schreiben Sie eine Deklaration eines privaten Datenfeldes tracks, um eine Sammlung von von Musiktrack_Objekten hält.

```
private ArrayList<Musiktrack> tracks;
```
Übung 4.7:
Schreiben Sie Zuweisung  an die Variablen bibliothek, cs101 und tracks, um eine entsprechenden ArrayList-Objekte zu erzeugen.

```
bibliothek = new ArrayList<Buch>();
```


```
cs101= new ArrayList<Student>();
```


```
tracks = new ArrayList<Musiktrack>();
```
Übung 4.8:
Wenn eine Sammlung 10 Elemente enthält, welchen Wert liefert dann ein Aufruf ihre Methode size?
→ 10  von 0-9.
Übung 4.9:
Schreiben Sie eine Methode , die mit Hilfe der Methode *get* das fünfte Objekt in einer Sammlung mit dem Namen *elemente* liefert.


----------



## fiber (8. Nov 2014)

@Gucky.
dann muss ich element.get(int) noch zuweisen?


----------



## Flown (8. Nov 2014)

Also wenn das so ist hätte ich das als HelperMethode gesehen und würde so aussehen:


```
import java.util.Arrays;
import java.util.List;

public class Test {
  public static void main(String[] args) {
    List<Integer> listInt = Arrays.asList(1, 2, 3, 4, 5);
    System.out.println(getFifthElementFrom(listInt));
    List<String> listString = Arrays.asList("a", "b", "c", "d", "e");
    System.out.println(getFifthElementFrom(listString));
  }
  
  public static <T> T getFifthElementFrom(List<T> elemente) {
    if (elemente.size() >= 5) {
      return elemente.get(4);
    }
    return null;
  }
}
```


----------



## fiber (8. Nov 2014)

Danke. Ich mach mal die nächsten Übungen und lese weiter und wenn ich die die ArrayList mehr vertiefe, dann kann ich die Übung bestimmt auch leichter lösen.


----------

