JAVA: Strings filtern nur 0.9 und a.z bzw A.Z

[Steve_O (Gast)]

Hallo, ich lese eine Datei zeilenweise in ein String ein. Im String sind 
dann auch Steuerzeichen und ?/ ...

Wie filtere ich die raus? Es sollen nur 0...9 sowie A...Z bzw a...z 
vorkommen dürfen.


Grüßle Steve_O

[Gast (Gast)]

Zum Beispiel regulaere Ausdruecke benutzen, etwa java.util.regex aber 
gibt auch noch mehr mit regular expressions.

[Bobby (Gast)]

Ich kann kein Java.

Vielleicht hilft Dir folgendes an C angelehnte Codebeispiel


bool Filtere_Zeichen (char x)
{
  if (x >= '0') and (x <= '9') then return true;
  if (x >= 'A') and (x <= 'Z') then return true;
  if (x >= 'a') and (x <= 'z') then return true;

  return false;
}

[mandrake (Gast)]

Die Klasse die du brauchst heißt FilterReader.
Du erzeugst eine neue Klasse und vererbst alle Eigenschaften von 
FilterReader.
Dann überschreibst du die Methode "read".

/*Anlegen des Readers. LineFeedFilter löscht Zeilenumbrüche in Spalten.*/
        BufR = new BufferedReader(new LineFeedFilter(new FileReader(Dateiname)));

Ich habe mal einen Filter gebraucht, der mir Linefeeds herausfiltert 
wenn keine Carriage Return davor kommt.

Hier ist er:

public class LineFeedFilter extends FilterReader
{
    private int iLastSymbol=0;


    /**
     * Konstruktor ruft den Konstruktor der Vaterklasse auf
     * @param in Datenstrom vom Typ Reader
     */
    public LineFeedFilter(Reader in)
    {
        super(in);
    }

    /**
     * Liest ein einziges Zeichen aus dem Datenstrom und filtert Linefeeds dann heraus,
     * wenn das Zeichen davor kein Carriage Return war
     * @return gibt den ASCII-Code als int zurück
     */
    public int read() throws IOException
    {
        /*Symbol lesen: */
        int iSymbol = in.read();
        /*Wenn das gelesene Symbol ein LineFeed ist:*/
        if (iSymbol == 10)
        {
            /*Wenn das letzte Symbol ein Carriage Return war:*/
            if (iLastSymbol == 13)
            {
                /*Gebe das Linefeed zurück*/
                iLastSymbol = iSymbol;
                return iSymbol;
            }
            else
            {
                /*Gebe nichts zurück*/
                iLastSymbol = iSymbol;
                return ' ';
            }
        }
        else
        {
            /*Gib das gelesene Zeichen zurück*/
            iLastSymbol = iSymbol;
            return iSymbol;
        }
    }

    /**
     * Liest len Zeichen in den Puffer beginnend bei Zeichen off
     */
    public int read(char[] cbuf, int off, int len) throws IOException
    {
        /*off Zeichen auslassen:*/
        this.skip(off);
        /*Lesen der len Zeichen in den Puffer:*/
        for (int i=0; i < len; i++)
        {
            int iCh = this.read();
            if (iCh == -1)
            {
                if (i==0) return -1;
                else return i;
            }
            else
            {
                cbuf[i] = (char) iCh;
            }
        }
        return len;
    }
}

[Kai G. (runtimeterror)]

>Die Klasse die du brauchst heißt FilterReader.
Ist das nicht etwas oversized?

Ich tendiere auch zu den regulären Ausdrücken: /[0-9a-zA-Z]+/ sollte 
seinen Zweck erfüllen.

Es sei denn du brauchst noch mehr Infos aus der Quelldatei.

[Markus V. (valvestino)]

Kai Giebeler wrote:
>>Die Klasse die du brauchst heißt FilterReader.
> Ist das nicht etwas oversized?
>
> Ich tendiere auch zu den regulären Ausdrücken: /[0-9a-zA-Z]+/ sollte
> seinen Zweck erfüllen.
>
> Es sei denn du brauchst noch mehr Infos aus der Quelldatei.

Nö, das ist nicht oversized sondern elegant.

In Java ist das genau die Vorgehensweise, wie sie die Designer der 
Stream-Klassen vorgesehen haben.

Einen kleinen Haken habe ich an Mandrakes Beispiel allerdings gefunden. 
Er implementiert die Methode read(char[] buf,...) anders, als die 
Super-Klasse FilterReader. Der Parameter "ofs" wird als Offset im Stream 
verwendet. Er ist jedoch laut API-Doc der Offset im char-Array, ab dem 
die gelesenen Daten gespeichert werden.

Daher dürfte für Steve_O die Neuimplementierung der Methode nicht 
erforderlich sein.

Gruß
Markus