Nach Programmdurchlauf werden Zeichen falsch dargestellt + Anderes Verhalten unter Windows

[Melamed]

Hallo!

Ich habe den Auftrag bekommen, für eine NGO ein Programm zu schreiben, das bei der Migration der Daten in ein neues CMS behilflich ist.
Ich habe das ganze jetzt in Java gelöst und bei mir unter Linux funktioniert eigentlich alles einwandfrei - außer vielleicht Folgendes:

Nach dem Programmdruchlauf werden bestimmte Sonderzeichen (beispielsweise: á wird zu �) falsch dargestellt. Kann das sein? Ich arbeite mit normalen Strings, sollte ich vielleicht etwas bestimmtes berücksichtigen, wenn ich mit Sonderzeichen arbeite?

Damit das Code-lesen etwas erträglicher wird eine Kurzbeschreibung:
Ich suche gezielt nach bestimmten Tags, die das vorige CMS erstellt hat und nicht W3C konform sind mittels RegEx, hole mir die Link- und Mailadressen heraus und mache sie HTML-tauglich.
Bei mir unter Linux läuft alles ganz koscher... Unter Windows plötzlich werden nur mehr die Mail-Tags erkannt (die Verunstaltung der Buchstaben bleibt leider...)

Wer es selbst versuchen will: Ich halte nach den Tags:

• <mail=mailadresse@provider.org>
• <link kulso="www.webadresse.hu">

Ausschau zudem lösche ich einen fehlplatzierten </mail=mailadresse@provider.org> Tag

Der Source-Code:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package regextest;

import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * @author qohelet
 */
public final class TagsExtrahierenClass {

    public static void main(String[] args) {
        TagsExtrahierenClass markup = new TagsExtrahierenClass();
        String text = "<li>  The database can be found at <link kulso=\"www.link.hu/anhangnachslaesch.html\">.<br><mail=adresse@provider.org>blabla</mail=adresse@provider.org></small></ol>";
        text = TagsExtrahierenClass.getCorrection(text, "<link kulso=\".*?\".*?>", "<http>(http:[/][/]|[url]www.)([/url][a-z]|[A-Z]|[0-9]|[/.]|[~])", 'l');
        text = TagsExtrahierenClass.getCorrection(text, "<mail=\\w[\\w|\\.|\\-]+@\\w[\\w|\\.|\\-]+\\.[a-zA-Z]{2,4}>", "<mail=\\w[\\w|\\.|\\-]+@\\w[\\w|\\.|\\-]+\\.[a-zA-Z]{2,4}>", 'd');
        text = TagsExtrahierenClass.getCorrection(text, "</mail=\\w[\\w|\\.|\\-]+@\\w[\\w|\\.|\\-]+\\.[a-zA-Z]{2,4}>", "<mail=\\w[\\w|\\.|\\-]+@\\w[\\w|\\.|\\-]+\\.[a-zA-Z]{2,4}>", 'x');

        System.out.println("here it is:");
        System.out.println(text);

    }

    /**
     * Diese Funktion gibt einen korrigierten Text zurück.
     * Der gesendete Text wird auf den ersten regulären Ausdruck überprüft.
     * Danach sucht das Programm im gefundenen Ausdruck nach dem zweiten Ausdruck.
     * Der Rückgabewert ist ein Text, der der W3C-Konvention entspricht
     * @param text
     * Der zu durchsuchende Text
     * @param tagregex
     * Regulärer Ausdruck für den gesamttag
     * @param contentregex
     * Regulärer Ausdruck für das Innenleben des Tags
     * @param mode
     * Was herauskommen soll... Derzeit unterstützt:
     * h -<a href="www.myaliyah.wordpress.com">www.myaliyah.wordpress.com</a>
     * l - das gleiche wie für "h" allerdings wird anstatt des zweiten regulären Ausdrucks einfach alles im ersten gelöscht, was nicht die Adresse darstellt
     * m -<a href="mailto:adresse.andererteilderadresse@gmail.com">adresse.andererteilderadresse@gmail.com</a>
     * d - das gleiche wie für "m" allerdings wird anstatt des zweiten regulären Ausdrucks einfach alles im ersten gelöscht, was nicht die Adresse darstellt
     * x - </mail=adresse@provider.org> löschen
     * @return
     * Der verbesserte Text
     */
    public static String getCorrection(String text, String tagregex, String contentregex, char mode) {
        ArrayList<String> taglist;  //Enthält den Gesamttag
        ArrayList<String> adrlist;  //Enthält den Inhalt des Gesamttags

        //Alle Tags aus dem Text holen
        taglist = getTags(text, tagregex);

        //Alle Inhalte aus dem Text holen

        //In diesem Fall wurde kein geeigneter Ausdruck gefunden
        //Daher zerklaubt man einfach den Gesamtausdruck
        if (mode == 'l' || mode == 'd' || mode == 'x') {
            adrlist = makemyadr(taglist, mode);
        } //Hier läuft alles wie geplant
        else {
            adrlist = getTags(text, contentregex);
        }

        return CorrectText(text, taglist, adrlist, mode);
    }

    /**
     * Die Aufgabe dieser Funktion besteht darin,
     * den eingegebenen Text nach dem Ausdruck zu durchsuchen.
     * Zurück kommt eine Arrayliste mit den Tags, die mit dem Ausdruck zusammenpassen
     *
     * @param text
     * Der zu durchsuchende Text
     * @param regex
     * Der reguläre Ausdruck
     * @return
     * Eine Liste mit den "gefangenen" Ausdrücken
     */
    private static ArrayList getTags(String text, String regex) {
        ArrayList ausgabe = new ArrayList();

        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(text);

        boolean result = m.find();

        while (result) {
            ausgabe.add(m.group());
            text = text.substring(m.end(), text.length());
            m = p.matcher(text);
            result = m.find();
        }

        return ausgabe;
    }

    /**
     * Verbessert den Text
     * @param text
     * Text
     * @param taglist
     * Zu verbessernde Parameter
     * @param adrlist
     * Inhalte der Parameter
     * @param mode
     * Modus - entweder (h)tml oder (m)ail
     * @return
     * Verbesserter text
     */
    private static String CorrectText(String text, ArrayList<String> taglist, ArrayList<String> adrlist, char mode) {

        for (int i = 0; i < taglist.size(); i++) {
            if (mode == 'h' || mode == 'l') {
                text = text.replaceAll(taglist.get(i), "<a href=\"" + adrlist.get(i) + "\">" + adrlist.get(i) + "</a>");
            }

            if (mode == 'm' || mode == 'd') {
                text = text.replaceAll(taglist.get(i), "<a href=\"mailto:" + adrlist.get(i) + "\">" + adrlist.get(i) + "</a>");
            }

            if (mode == 'x') {
                text = text.replaceAll(taglist.get(i), "");
            }
        }

        return text;
    }

    /**
     *
     * Aufgabe dieser Funktion ist es, aus dem Tag die jeweilige Adresse auszuschneiden
     * @param taglist
     * Liste mit den Tags
     * @param mode
     * Modus:
     * d & Rest für HTML
     * l & x für Mail
     * @return
     * Adressen
     */
    private static ArrayList<String> makemyadr(ArrayList<String> taglist, char mode) {
        ArrayList<String> retarr = new ArrayList(taglist.size());
        for (int i = 0; i < taglist.size(); i++) {
            if (mode == 'd' || mode == 'x') {
                if (mode == 'd') {
                    String tmpmail = taglist.get(i);
                    tmpmail = tmpmail.replace("<mail=", "");
                    tmpmail = tmpmail.replace(">", "");
                    retarr.add(tmpmail);
                } else {
                    String tmpmail = taglist.get(i);
                    tmpmail = tmpmail.replace("</mail=", "");
                    tmpmail = tmpmail.replace(">", "");
                    retarr.add(tmpmail);
                }
            } else {
                String tmphtml = taglist.get(i);
                tmphtml = tmphtml.replace("<link kulso=\"", "");
                tmphtml = tmphtml.replace("\">", "");
                retarr.add(tmphtml);
            }
        }
        return retarr;

    }
}

Würde mich freuen, wenn mir jemand helfen kann. DANKE!

 

[Ezra]

Du solltest Deine Projekte mit UTF-8 erstellen. Falls Du Eclipse nutzt, lässt sich die Codierung unter Windows einfach in den Einstellungen ändern.

 

[Melamed]

Danke einmal für die schnelle Antwort!

Ich verwende NetBeans, bis dato habe ich aber noch nie mit solchen Problemen zu tun gehabt.
Hast du einen Link oder sonstige Information, wie ich die Änderung bewerkstellige?
Bzw. - muss ich auch im Source-Code etwas ändern? Ich kann mich dunkel daran erinnern, dass ich irgendwo eine String-Codierung einstellen konnte...

 

[Ezra]

Mit Netbeans kenne ich mich nicht aus. Aber irgendwer hier wird das schon wissen, ansonsten kannst Du ja auch mal googlen oder die Einstellungen selbst durchforsten.

Edit: Hier ist sowas: NetBeans-Forum &bull; Thema anzeigen - netbeans mit utf8

 

[Gast2]

Das sind aber zwei Paar Schuhe. Das Projekt auf UTF-8 stellen heißt einfach nur das die Source-Files in UTF-8 abgespeichert werden.

Strings sind in Java by Default immer UTF-16 somit hast du eigentlich keine Probleme mit UTF-8.

Ich gehe davon aus das dein Problem nicht in dem geposteten Code entsteht sondern an der Stelle wo du die Quellen einließt per HTTP oder FileReader...

 

[Melamed]

@fassy:
Dieser Code stellt lediglich die Erweiterung eines anderen Projektes dar, das bis jetzt ohne Probleme funktioniert hat.

Aber zur Information stelle ich gerne den Einlese-Code online...

BufferedReader in = new BufferedReader(new FileReader(path));
            String s_tmpath = new String();
            s_tmpath = tmpath(path);
            File tmpFile = new File(s_tmpath);
            BufferedWriter out = new BufferedWriter(new FileWriter(tmpFile));
            String zeile = "";
while ((zeile = in.readLine()) != null) {
...
}

 

[Ark]

Genau aus solchen Gründen meide ich FileReader und FileWriter, wo es nur geht: Sie zwingen einen dazu, den Zeichensatz des Betriebssystems zu benutzen. Besser ist es, alles schön auszuschreiben:

// Zum Lesen:
BufferedReader in = new BufferedReader(
	new InputStreamReader(
		new FileInputStream(new File("einzulesen.txt")),
		"UTF-8"
	)
);

// Zum Schreiben:
BufferedWriter out = new BufferedWriter(
	new OutputStreamWriter(
		new FileOutputStream(new File("rausgeschrieben.txt")),
		"UTF-8"
	)
);

Dieser Code arbeitet immer und nur mit UTF-8-Dateien. (Code ist ungetestet, wie immer 😉 )

Ark