Verkettete Listen in Java CD?
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.LinkedList;
import java.util.Random;
public class PlaylistReader {
public static void main(String[] args) {
LinkedList<Titel> playlist = new LinkedList<Titel>();
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("titel.txt"));
String name = br.readLine(); // Name der CD aus erster Zeile
String line = "";
while ((line = br.readLine()) != null) {
String[] parts = line.split(";");
int cdNr = Integer.parseInt(parts[0].replaceAll("\\D+", ""));
int trackNr = Integer.parseInt(parts[1]);
String interpret = parts[2];
String title = parts[4];
String duration = parts[5];
Titel t = new Titel(cdNr, trackNr, interpret, name, title, duration);
playlist.add(t);
}
br.close();
Random rand = new Random();
int index = rand.nextInt(playlist.size());
Titel zufallstitel = playlist.get(index);
System.out.println(zufallstitel.getName());
System.out.println("CD " + zufallstitel.getCdNr());
System.out.println("Titel Nr.: " + zufallstitel.getTrackNr());
System.out.println("Interpret: " + zufallstitel.getInterpret());
System.out.println("Titel: " + zufallstitel.getTitle());
System.out.println("Spielzeit: " + zufallstitel.getDuration());
} catch (Exception e) {
System.out.println("Fehler beim Einlesen der Datei: " + e.getMessage());
}
}
}
public class Titel {
private int cdNr;
private String duration;
private String interpret;
private String name;
private String title;
private int trackNr;
public Titel(int cdNr, int trackNr, String interpret, String name, String title, String duration) {
this.cdNr = cdNr;
this.trackNr = trackNr;
this.interpret = interpret;
this.name = name;
this.title = title;
this.duration = duration;
}
public int getCdNr() {
return cdNr;
}
public void setCdNr(int cdNr) {
this.cdNr = cdNr;
}
public String getDuration() {
return duration;
}
public void setDuration(String duration) {
this.duration = duration;
}
public String getInterpret() {
return interpret;
}
public void
setInterpret(String interpret) {
this.interpret = interpret;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getTrackNr() {
return trackNr;
}
public void setTrackNr(int trackNr) {
this.trackNr = trackNr;
}
}
1 Antwort
typische ki-frage. hab das mal für dich erledigt:
# Verkettete Listen in Java: CD-Playlist-Analyse
Ihr Code demonstriert eine gute Anwendung von verketteten Listen in Java zur Verwaltung einer CD-Playlist. Hier ist eine Analyse und einige mögliche Verbesserungen:
## Aktuelle Implementierung
1. **LinkedList Nutzung**:
- Sie verwenden `LinkedList<Titel>` zur Speicherung der Titel
- Vorteile: Dynamische Größe, einfaches Hinzufügen von Elementen
2. **Dateieinlese-Logik**:
- Lesen einer Textdatei mit CD-Informationen
- Parsen der Daten und Erstellen von `Titel`-Objekten
3. **Zufällige Titelauswahl**:
- Nutzung von `Random` für zufällige Auswahl eines Titels
## Verbesserungsvorschläge
1. **Try-with-Resources** für besseres Ressourcenmanagement:
```java
try (BufferedReader br = new BufferedReader(new FileReader("titel.txt"))) {
// Ihr Code hier
} catch (Exception e) {
System.out.println("Fehler beim Einlesen der Datei: " + e.getMessage());
}
```
2. **Fehlerbehandlung** für das Parsen:
```java
try {
cdNr = Integer.parseInt(parts[0].replaceAll("\\D+", ""));
trackNr = Integer.parseInt(parts[1]);
} catch (NumberFormatException e) {
System.err.println("Ungültiges Zahlenformat in Zeile: " + line);
continue;
}
```
3. **Record-Klasse** (ab Java 16):
```java
public record Titel(int cdNr, int trackNr, String interpret, String name,
String title, String duration) {}
```
4. **Generische Methoden** für Playlist-Operationen:
```java
public static Titel getRandomTitel(LinkedList<Titel> playlist) {
if (playlist.isEmpty()) return null;
return playlist.get(new Random().nextInt(playlist.size()));
}
```
5. **Alternative Collections**:
- Bei vielen Zugriffen könnte `ArrayList` performanter sein
- Bei häufigen Einfüge-/Löschoperationen ist `LinkedList` besser
## Erweiterungsmöglichkeiten
1. **Playlist-Sortierung**:
```java
playlist.sort(Comparator.comparingInt(Titel::getTrackNr));
```
2. **Gruppierung nach CD**:
```java
Map<Integer, List<Titel>> cds = playlist.stream()
.collect(Collectors.groupingBy(Titel::getCdNr));
```
3. **Serialisierung** für Speicherung:
```java
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("playlist.ser"))) {
oos.writeObject(playlist);
}
```
Ihre Implementierung ist bereits gut strukturiert und zeigt die praktische Anwendung von LinkedLists in Java. Die vorgeschlagenen Verbesserungen würden die Robustheit und Wartbarkeit des Codes weiter erhöhen.
Welches Modell war das? Ziemlich schwache Tipps.
Abgesehen davon ist mir immer noch unklar, was der FS eigentlich fragt, aber das kann die KI auch nicht erraten ;-)