Verketten von Strings funktioniert nicht

Guten Abend zusammen,

ich möchte gerne ein Programm entwickeln, mit dem ich anhand von IDTags Informationen aus MP3 Dateien auslese und anhand dieser Informationen die MP3 Datei umbenenne. Dabei habe ich ein Problem bei einer eigentlich simplen Stringverkettung.

Der Code der Starterklasse:
Java:
package sebastian;

import java.io.File;
import java.io.IOException;

import MP3.IdTagAuslesen;

public class Starter {
  
    public static void main(String[] args) throws IOException {  
      
        String pfad = "/home/sebastian/test.mp3";  
      
        IdTagAuslesen idTagger = new IdTagAuslesen();
        idTagger.auslesen(pfad);

        File k = new File(pfad);
        String name = k.getName();
        String pfadroot = k.getParent();
        String interpret = idTagger.Interpret;
        String titel = idTagger.Titel;
      
        String finalname = pfadroot + "/" + interpret + " - " + titel + ".mp3";
        String finalname2 = interpret.concat(titel);
        String finalname3 = pfadroot + "/" + "Guns N' Roses" + " - " + "Knockin' On Heavens Door" + ".mp3";
        String finalname4 = pfadroot + "/" + idTagger.Interpret + " - " + idTagger.Titel + ".mp3";
      
      
        System.out.println(interpret);
        System.out.println(titel);
        System.out.println(idTagger.Interpret);
        System.out.println(idTagger.Titel);
        System.out.println("finalname : " + finalname);
        System.out.println("finalname2: " + finalname2);
        System.out.println("finalname3: " + finalname3);
        System.out.println("finalname4: " + finalname4);
      
        File file = new File(finalname);
      
        k.renameTo(file);      
    }
}

Dieses Programm gibt folgendes auf der Console aus:
Code:
Guns N' Roses
Knockin' On Heavens Door
Guns N' Roses
Knockin' On Heavens Door
finalname : /home/sebastian/Guns N' Roses
finalname2: Guns N' Roses
finalname3: /home/sebastian/Guns N' Roses - Knockin' On Heavens Door.mp3
finalname4: /home/sebastian/Guns N' Roses

Wie man hier schön sieht, schlägt jedesmal sobald die Attribute Titel und Interpret aus dem Objekt idTagger verwendet werden, die Verkettung der einzelnen String fehl (finalname, finalname2 und finalname4). Nur bei finalname3 funktioniert es, wo Titel und Interpret nicht aus den Attributen des Objekts bezogen werden.

Die Klasse IdTagAuslesen() aus der das Objekt idTagger gebildet wird sieht folgendermaßen aus:

Java:
package MP3;

import java.io.FileInputStream;
import java.io.IOException;

public class IdTagAuslesen
{
    public String Titel;
    public String Interpret;
   
    public void auslesen (String filename)
    {
        FileInputStream fis = null;
        long groesseMB3 = 0;
        byte bTAG [] = new byte [3];
        byte bTitel [] = new byte [30];
        byte bInterpret [] = new byte [30];
        byte bCDTitel [] = new byte [30];
        byte bJahr [] = new byte [4];
        byte bKommentar [] = new byte [30];
        byte bGenre = 0;
               
        try
        {
            // filename = in.nextLine();
            fis = new FileInputStream(filename);
            groesseMB3 = fis.available();
            //Datensatzzeiger positionieren
            fis.skip(groesseMB3-128);
            fis.read(bTAG); //TAG lesen
            String strTAG = new String(bTAG);
            fis.read(bTitel); //Titel lesen
            String strTitel = new String(bTitel);
            fis.read(bInterpret);//Interpret lesen
            String strInterpret = new String(bInterpret);
            fis.read(bCDTitel);//CDTietel lesen
            String strCDTitel = new String(bCDTitel);
            fis.read(bJahr);//Jahr lesen
            String strJahr = new String(bJahr);
            fis.read(bKommentar);//Kommentar lesen
            String strKommentar = new String(bKommentar);
            bGenre = (byte)fis.read();//Genre lesen
           
            this.Titel = new String(bTitel);
            this.Interpret = new String(bInterpret);
           
            /*
            System.out.println("Dateigroesse: " + groesseMB3);
            System.out.println("Tag: " + strTAG);
            System.out.println("Titel: " + strTitel);
            System.out.println("Interpret: " + strInterpret);
            System.out.println("CD-Titel: " + strCDTitel);
            System.out.println("Jahr: " + strJahr);
            System.out.println("Kommentar: " + strKommentar);
            System.out.println("Genre: " + bGenre);
            */
           
            fis.close();
        }
        catch (IOException err)
        {
            System.out.println("Fehler: " + err);
        }    
    }
}

Was mache ich hier falsch, so dass ich die Attribute des Objekts idTagger nicht verwenden kann? Vielen Dank und viele Grüße!
 
Ich vermute Folgendes:

Für den Titel ließt du z.B. 30 bytes aus. Der Titel ist aber gar nicht so lang. Das heißt das Byte-Array bTitel hat hinten nur Nullen stehen. Wenn man daraus einen String erzeugt können diese Nullen nicht interpretiert werden. Das könnte zu Problemen bei der Konkatenation führen.

Versuch mal den String nur aus denjenigen bytes zu erzeugen die ungleich 0 sind:
Java:
      int titelByteCount = 0;
       while (titelByteCount < bTitel.length && bTitel[titelByteCount] != 0) {
         titelByteCount++;
       }

       int interpretByteCount = 0;
       while (interpretByteCount < bInterpret.length && bInterpret[interpretByteCount] != 0) {
         interpretByteCount++;
       }

       this.Titel = new String(bTitel, 0, titelByteCount);
       this.Interpret = new String(bInterpret, 0, interpretByteCount);
 
DU könntest dir auch für sowas (wie ich es in unserem Musik-Player gemacht habe) den MPEgAudioFileReader von der JLayer API benutzen und dann direkt die Werte auslesen, damit müsstest du dich mit sowas nicht rumärgern, zudem nichtmal gegeben ist, das der ID3-Tag immer so aufgebaut ist.

Als Anregung ein Konstruktor aus der Klasse:

Java:
 public Song(File audioFile) throws UnsupportedAudioFileException, IOException {
        this.audioFile = audioFile;
        try {
            if (audioFile.getName().endsWith(".mp3")) {
                properties = new MpegAudioFileReader().getAudioFileFormat(audioFile).properties();
                if (properties != null) {
                    this.title = (String) properties.get("title");
                    this.interpret = (String) properties.get("author");
                    this.album = (String) properties.get("mp3.id3tag.orchestra");
                    this.date = (String) properties.get("date");
                    this.id3TagTrack = (String) properties.get("mp3.id3tag.track");
                    this.genre = (String) properties.get("mp3.id3tag.genre");
                    this.discography = (String) properties.get("mp3.id3tag.disc");
                    this.composer = (String) properties.get("mp3.id3tag.composer");
                    this.id3TagGrouping = (String) properties.get("mp3.id3tag.grouping");
                    this.id3TagEncoded = (String) properties.get("mp3.id3tag.encoded");
                    this.publisher = (String) properties.get("mp3.id3tag.publisher");
                    this.id3TagLength = (String) properties.get("mp3.id3tag.length");
                    this.channels = (int) properties.get("mp3.channels");
                    this.mPegVersion = Integer.parseInt(
                            (String) properties.get("mp3.version.mpeg"));
                    this.framesize = (int) properties.get("mp3.framesize.bytes");
                    this.mp3VersionLayer = Integer.parseInt(
                            (String) properties.get("mp3.version.layer"));
                    this.frameLength = (int) properties.get("mp3.length.frames");
                    this.bitrate = (int) properties.get("mp3.bitrate.nominal.bps");
                    this.encoding = new AudioFormat.Encoding(
                            (String) properties.get("mp3.version.encoding"));
                    this.id3TagV2 = (ByteArrayInputStream) properties.get("mp3.id3tag.v2");
                    this.id3TagV2Version = (String) properties.get("mp3.id3tag.v2.version");
                    this.padding = (boolean) properties.get("mp3.padding");
                    this.byteLength = (int) properties.get("mp3.length.bytes");
                    this.frameRate = Double.parseDouble(
                            Float.toString((float) properties.get("mp3.framerate.fps")));
                    this.frameRate = (Float) properties.get("mp3.framerate.fps");
                    this.duration = (long) properties.get("duration");
                    this.frequency = (int) properties.get("mp3.frequency.hz");
                    this.headerPos = (int) properties.get("mp3.header.pos");
                    this.comment = (String) properties.get("comment");
                    this.original = (boolean) properties.get("mp3.original");
                }
            } else if (audioFile.getName().endsWith(".wav")) {
                AudioFileFormat affmt = AudioSystem.getAudioFileFormat(audioFile);
                AudioFormat fmt = affmt.getFormat();
                properties = fmt.properties();
                if (properties == null || properties.isEmpty()) {
                    properties = affmt.properties();
                }
                System.out.println("Properties empty: " + properties.isEmpty());
                try (Clip clip = AudioSystem.getClip()) {
                    clip.open(AudioSystem.getAudioInputStream(new AudioFormat(
                            fmt.getSampleRate(),
                            16,
                            fmt.getChannels(),
                            true,
                            fmt.isBigEndian()), AudioSystem.getAudioInputStream(audioFile)));
                    this.duration = clip.getMicrosecondLength();
                    this.title = audioFile.getName().substring(
                            0, audioFile.getName().lastIndexOf('.'));
                    this.framesize = fmt.getFrameSize();
                    this.channels = fmt.getChannels();
                    this.frameRate = fmt.getFrameRate();
                    this.bitrate = fmt.getSampleSizeInBits();
                    this.encoding = fmt.getEncoding();
                }
            } else {
                throw new UnsupportedAudioFileException("Unsupported Audiofile: " + audioFile);
            }
        } catch (UnsupportedAudioFileException | IOException ex) {
            System.err.println(audioFile + " ist keine gültige Audio-Datei!");
            throw ex;
        } catch (LineUnavailableException ex) {
            throw (UnsupportedAudioFileException) new UnsupportedAudioFileException(
                    "Unsupported Audiofile: " + audioFile).initCause(ex);
        }
    }

Und dann hat diese Klasse noch andere Konstruktoren mit ner URL... und eben Getter für die einzelnen Attribute. Hat bei uns problemlos funktioniert (Steht ein gewisser Wert nicht in der Datei, werden die jeweiligen getter Standardwerte wie einen leeren String oder 0/false zurückgeben)
 

Zurück
Oben