Klassen Zugriff auf verschachtelte Objekte

[flojava]

Hallo Leute,

ich komme aus der PHP-Welt und tu mir noch etwas schwer wie mehrdimensionale Arrays in Java umgesetzt werden. Da ich gelesen habe, dass man in Java hierzu eher Objekte einsetzt, hier mein Ansatz:

Die Datenstruktur

word: katze
____wordDescription: Tier macht miau
____wordDescription: Tier klettert auf Bäume
word: hund
____wordDescription: Tier bellt
____wordDescription: Tier wedelt mit dem Schwanz
____wordDescription: Tier geht gern Gassi

Jeder Datensatz besteht aus einem "word" und einer beliebigen Anzahl von "wordDescription"

Meine gewählte Klassenstruktur

Klasse Word: Besteht aus den Eigenschaften "word " (ist ein String, Beispiel: katze) und "wordDescription" (ist eine ArrayList "Beispiel: Tier macht miau, Tier kletter auf Bäume ...)

Klasse WordList: Das ist eine (Sammel)Klasse für die Objekte Word die aus der Eigenschaft allWords (ist eine List<Objects>) besteht.

Frage
Im Anhang seht Ihr aus dem Debugging-Tool von Eclipse wie die gefüllte Datenstruktur aussieht. Mir ist nun nicht klar wie ich auf die Daten "word" und "wordDescriptions" zugreifen kann.

Hier noch die Übersicht der main-Klasse:

public static void main(String[] args){       
       
        Word katze = new Word("katze");
       
        katze.addWordDescription("Tier macht miau");
        katze.addWordDescription("Tier kuschelt gerne");
           
        WordList neueListe = new WordList();
        neueListe.addWord(katze);
   
    }

Vielen Dank für Eure Unterstützung und schöne Grüße
Florian

 

[neoexpert]

neueListe.get(0).getWordDescription(0);

 

[neoexpert]

getWordDescription in der Klasse "Word" wird dann so aussehen:

public E getWordDescription(int p){return wordDrscriptions.get(p);}

Ich denke E ist bei dir String oder?

 

[neoexpert]

Aber deine Frage war zu den Mehrdimensionalen Arrays. Arrays in Java haben eine Feste grösse. Will man dynamische grösse haben kann man, wie du es schon tust: ArrayList oder andere Collections verwenden. Mehrdimensionale Liste kann man z.B. als Liste von Listen implementieren:

ArrayList<ArrayList<Object>> l= new ArrayList<ArrayList<Object>>();
l.add(new ArrayList<Object>());
l.get(0).add("wort");
Object o=l.get(0).get(0);
boolean b=o instanceof String;
if(o){
String s=(String)o;
}

 

[flojava]

Hallo neoexpert,

vielen Dank für Deine superschnelle Antwort. Ich hab es mit diesem Hinweis "neueListe.get(0).getWordDescription(0);" hinbekommen. Allerdings hatte ich noch ein Fehler in der Klasse WordList. Hier hatte ich als Rückgabewert List<Object> statt List<Word> angegeben.

Schöne Grüße
Florian

 

[flojava]

Ich denke E ist bei dir String oder?

Ich gebe hier eine List<String> zurück

 

[neoexpert]

Ok. Java mag im Vergleich zu php wenige vorteile mitbringen und dann auch noch so kompliziert erscheinen. In PHP kann man ja z.B. assoziative arrays sehr einfach implementieren:

$a=new Array();
$a["name"]="peter";

In Java kann man das auch machen aber nicht so schön wie in PHP:

Map<String,String>=new HashMap<String,String>();
map.put("name","peter");

Allerdings kann man in Java auch Objects anstelle von Strings verwenden:
HashMap<Point,Object>
So kann man z.B. jedem Punkt im Raum einen Object zuweisen. Auf den man sehr schnell zugreifen kann: HashMap basiert auf einem Array.
Die klasse Point muss allerdings die Methode equals überschreiten, aber dazu später mehr.

 

[Flown]

Da du ja deine Datenstruktur schon selbst gewählt hast, würde ich dir noch raten die WordList als eine built-in Liste zu halten, dann sieht dein Code eventuell so aus:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

public class Test {
  public static void main(String... args) {
    Word katze = new Word("katze");
    katze.addDescription("Tier macht miau");
    katze.addDescription("Tier klettert auf Bäume");
    
    Word hund = new Word("hund");
    hund.addDescription("Tier bellt");
    hund.addDescription("Tier wedelt mit dem Schwanz");
    hund.addDescription("Tier geht gern Gassi");
    
    List<Word> wordList = Arrays.asList(katze, hund);
    for (Word word : wordList) {
      System.out.println("word: " + word.getWord());
      System.out.println("descriptions: " + word.getDescriptions());
    }
    
    System.out.println(wordList);
  }
}

class Word {
  private final String word;
  private final List<String> descriptions;
  
  public Word(String word) {
    this.word = word;
    this.descriptions = new ArrayList<>();
  }
  
  public String getWord() {
    return word;
  }
  
  public List<String> getDescriptions() {
    return Collections.unmodifiableList(descriptions);
  }
  
  public void addDescription(String description) {
    descriptions.add(description);
  }
  
  @Override
  public int hashCode() {
    return Objects.hash(word, descriptions);
  }
  
  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    Word other = (Word) obj;
    if (!Objects.equals(word, other.word)) {
      return false;
    }
    if (!Objects.equals(descriptions, other.descriptions)) {
      return false;
    }
    return true;
  }
  
  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("word: ").append(word).append(System.lineSeparator());
    for (String description : descriptions) {
      builder.append("____wordDescription: ").append(description).append(System.lineSeparator());
    }
    return builder.toString();
  }
}

 

[flojava]

Da du ja deine Datenstruktur schon selbst gewählt hast, würde ich dir noch raten die WordList als eine built-in Liste zu halten, dann sieht dein Code eventuell so aus:

Hallo Flown,

vielen Dank für Dein Feedback. Ich hab gestern Nacht schon weitergearbeitet, daher möchte ich jetzt ungern alles über Bord werfen. Ehrlich gesagt tue ich mir mit Deinem Quellcode auch noch schwer. Ich recherchiere aber weiter zur built-in List und hoffe dass ich dann das Prinzip verstehe

Schöne Grüße

Florian

 

[Jardcore]

Build-in Liste heißt hier einfach nur das du ein Objekt hast, welches eine Referenz auf eine Liste hat.
Du kannst das Objekt dann nach der Liste fragen und durch das Objekt die Liste erweitern.

 

[flojava]

Hallo Jardcore,

ist das ein verbreiteter Begriff? Ich möchte gerne mehr darüber lesen, habe aber bisher nicht darüber gefunden. Letztendlich lande ich immer auf Seiten die ein normale List beschreiben.

Danke und schöne Grüße

Florian

 

[Salo]

Sicher?
Wenn du nach, built in list java, suchst, dann ist doch der erste link direkt ein treffer.

Falls dir das nicht reicht, suchst du eben so:
"built-in list" siteracle.com

Achtung! Lass die anführungszeichen drin.
Du kannst natürlich auch noch in anderen seiten suchen, aber oracle.com ist glaub ich die umfangreichste.(es wird ja auchnoch z.Bsp. docs.oracle.com durchsucht)