Datei einlesen, nach Begriff filtern und in Datei ausgeben. Problem Standardausgabe über Konsole

[popeye2803]

Moin,
ich möchte ein Programm schreiben, welches den UNIX-Befehl grep nachstellt, d.h. eine Datei einlesen, in dieser Datei nach einen eingegebenen Begriff suchen und die Zeilen, wo der Begriff drin vorkommt in eine neue Datei schreiben.
Das klappt auch alles soweit.
Ich habe nur das Problem, dass die Standardausgabe über die Konsole erfolgen soll, wenn kein Dateiname (writer) für die Ausgabe-Datei angegeben ist.
Allerdings bekomme ich eine NullPointerException, wenn ich Null übergebe.

[CODE lang="java" title="grep"]grep(args[0], new FileReader(args[1]), new FileWriter(args[2]));[/CODE]

[CODE lang="java" title="grep"]static void grep(java.lang.String regex, java.io.Reader reader, java.io.Writer writer) throws IOException {

BufferedReader in = new BufferedReader(reader);

BufferedWriter bufOut = new BufferedWriter (writer);
PrintWriter out = new PrintWriter(bufOut);

String line;

ArrayList<String> text = new ArrayList<String>();
while (null != (line = in.readLine())) {
if(line.contains(regex)) {
text.add(line);
}
}

if (writer != null) {
for (String newText : text)
out.write(newText + "\n");
}else {
for (String newText : text)
System.out.print(newText + "\n");
}
in.close();
out.close();
}
}[/CODE]

 

[kneitzel]

Du musst die Argumente doch nur validieren. Und wenn das Argument nicht gegeben wurde oder ungültig ist, dann erzeugst Du keinen FileWriter sondern erstellst einen neuen OutputStreamWriter auf System.out.

Oder habe ich Dein Problem irgendwie missverstanden?

 

[popeye2803]

Genau, das habe ich auch.
Eine mögliche Eingabe in der Konsole wäre:
$ java Grep sea kubla.txt

Da würden die folgenden Argumente übergeben:
args[0] = sea
args[1] = kubla.txt
args[2] = null

Hier ist noch meine vorherige Implementierung:

[CODE lang="java" title="Main"]public static void main(String[] args) throws IOException {

String grepComand = "$ java Grep";

Scanner ir = new Scanner(System.in);
String inputComand = ir.nextLine();
String[] input = inputComand.split(" ");

args = input;

String inputGrepComand = input[0] + " " + input[1] + " " + input[2];

if (inputGrepComand.equals(grepComand) && input.length < 4) {
System.out.println("usage: Grep PATTERN [from-file] [to-file]");
} else if (inputGrepComand.equals(grepComand) && input.length < 4) {
System.arraycopy(input, 3, args, 0, input.length - 3);
args[0] = null;
args[1] = null;
args[1] = null;
} else if (inputGrepComand.equals(grepComand) && input.length < 5) {
System.arraycopy(input, 3, args, 0, input.length - 3);
args[1] = null;
args[2] = null;
args[3] = null;
} else if (inputGrepComand.equals(grepComand) && input.length < 6) {
System.arraycopy(input, 3, args, 0, input.length - 3);
args[2] = null;
args[3] = null;
args[4] = null;
} else if (inputGrepComand.equals(grepComand) && input.length < 7) {
System.arraycopy(input, 3, args, 0, input.length - 3);
args[3] = null;
args[4] = null;
args[5] = null;
} else {System.out.println("else");}

grep(args[0], new FileReader(args[1]), new FileWriter(args[2]));

}[/CODE]

 

[popeye2803]

Wenn ich null übergebe, kommt aber die NullPointerException und wenn ich statt null etwas fest reinschreibe, wird eine Datei mit dem Namen erstellt.

 

[kneitzel]

Also irgendwie kann ich Dir nicht folgen. Wenn es nur 2 Argumente gibt, dann solltest Du eine IndexOutOfBoundsException bekommen, denn das String Array hat dann nur zwei Element!

Aber Du nutzt die übergebenen Argumente ja auch nicht sondern setzt args auf input.

Daher kann ich Deine Logik in keiner Weise nachvollziehen und das kleinste Problem scheint mir zu sein, dass Du da ständig einen neuen FileWriter erstellst - Was natürlich Unsinn ist, wenn Du es nicht in eine Datei schreiben willst.

 

[popeye2803]

Also irgendwie kann ich Dir nicht folgen. Wenn es nur 2 Argumente gibt, dann solltest Du eine IndexOutOfBoundsException bekommen, denn das String Array hat dann nur zwei Element!

Ja genau, das ist der Grund, warum ich args mit null initialisiere, wenn keine Ausgabedatei angegeben ist.

Wenn z.B. "$ java Grep sea kubla.txt new.txt" eingegeben wird, sollen die Zeilen, in denen "sea" vorkommt, in die Datei "new.txt" geschrieben werden. Das funktioniert auch.

Es klappt nur nicht, wenn ich nur "$ java Grep sea kubla.txt" Eingebe, dass es dann über die Konsole ausgegeben wird.
Und da fehlen mir so ein bisschen die Ansätze, was ich anpassen muss.

 

[mihe7]

Prinzip:

Writer writer;
if (args.length == 2) {
    writer = new OutputStreamWriter(System.out);
} else if (args.length == 3) {
    writer = new FileWriter(args[2]);
} else {
    // Fehlermeldung
}

 

[kneitzel]

Wobei ja die Frage ist, was Du da ja überhaupt treibst. Du sollst soch vermutlich ein Programm schreiben, dass direkt die Parameter auswertet. Also Nix mit Scanner! Nix mit Usereingabe! Nix mit String.split!

Also einfach mal das folgene Programm betrachten und mit Parametern aufrufen:

public class Test {

    public static void main(String[] args) {
        System.out.println("Anzahl Parameter: " + args.length);
        for (int index = 0; index < args.length; index++) {
            System.out.println(index + ". Argument: " + args[index]);
        }
    }

}

 

[popeye2803]

Wobei ja die Frage ist, was Du da ja überhaupt treibst. Du sollst soch vermutlich ein Programm schreiben, dass direkt die Parameter auswertet. Also Nix mit Scanner! Nix mit Usereingabe! Nix mit String.split!

Also einfach mal das folgene Programm betrachten und mit Parametern aufrufen:

public class Test {

    public static void main(String[] args) {
        System.out.println("Anzahl Parameter: " + args.length);
        for (int index = 0; index < args.length; index++) {
            System.out.println(index + ". Argument: " + args[index]);
        }
    }

}

Doch, es soll über eine Eingabe laufen.
Wenn der Befehl "$ java Grep" eingegeben wird, ist der nächste Begriff das Suchwort (regex), dann die Eingabe-Datei (reader) und dann die Ausgabe-Datei (writer).
Eingabe-Datei und Ausgabe-Datei sind aber nur optional. Wenn die Begriffe fehlen, soll für die Eingabe ein standard input definiert werden (Tastatur) und bei fehlender Ausgabe-Datei ein standard output (Konsole).


Grep ist in der API so vorgegeben:

static void grep(java.lang.String regex, java.io.Reader reader, java.io.Writer writer)

Copies all lines containing the search string from the Reader to the Writer.

Parameters:
regex - the search string as regular expression
reader - the input stream
writer - the output stream


Daher klappt meiner Meinung nach auch diese Lösung nicht:
[CODE lang="java" title="java"]Writer writer;
if (args.length == 2) {
writer = new OutputStreamWriter(System.out);
} else if (args.length == 3) {
writer = new FileWriter(args[2]);
} else {
// Fehlermeldung
}[/CODE]

 

[kneitzel]

Also ehrlich gesagt wundert mich das. Wenn man es als Eingabe im Programm hätte, dann würde das '$ java' bei der Ei gabe keinen Sinn machen. Selbst das Grep nicht, so dass die einzige Funktionalität wäre.

Das, was da in der Aufgabe angegeben wurde sieht nach einem Aufruf aus. Das $ ist das Zeichen der Shell. Das java ist halt das Programm, das aufgerufen wird und Grep der Name der Klasse mit der main Methode.
Danach kommen dann die Parameter, die dann in args zu finden sind.

Wenn du mit der Eingabe arbeiten willst, dann geht das natürlich auch. Aber dann nutzt du NICHT den args Parameter.

Und der vorgegebene Code zeigt, wie du einen Writer als zweites Argument bekommst. Du musst einen Writer für den zweiten Parameter bekommen und das ist entweder ein FileWriter oder eben ein OutputStreamWriter. Da beides von Writer erbt, kann es da verwendet werden.

 

[mihe7]

Wenn der Befehl "$ java Grep" eingegeben wird, ist der nächste Begriff das Suchwort (regex), dann die Eingabe-Datei (reader) und dann die Ausgabe-Datei (writer).

Wie @kneitzel schon schreibt: das ist eine typische Angabe für einen Befehl, wie er in der Shell einzugeben wäre. Wenn man eine solche Angabe für Windows geschrieben hätte, würde dort z. B. C:\> java Grep stehen.

 

[developer418]

Dein Code:

grep(args[0], new FileReader(args[1]), new FileWriter(args[2]));

static void grep(java.lang.String regex, java.io.Reader reader, java.io.Writer writer) throws IOException {
    ...
}

Lösungsansatz:

grep(args[0], args[1]), args[2]);

static void grep(String regex, String readerS, String writerS) throws IOException {
   Reader reader = new FileReader(readerS);
   Writer writer;
    ...
   if(writerS != null) {
        writer = new FileWriter(writerS);
        BufferedWriter bufOut = new BufferedWriter (writer);
        PrintWriter out = new PrintWriter(bufOut);
   }
   ...
}

 

[mihe7]

Lösungsansatz:

Die Idee hat einen entscheidenden Nachteil: die Methode muss nun viele Annahmen über Quelle und Ziel treffen. Wie gibst Du dort z. B. die Standardausgabe, die Fehlerausgabe oder einen Teil des Speichers für die Ausgabe an?

 

[developer418]

Hier noch ein einfacherer Code (Java 11):

[CODE lang="java" title="Idee für grep in file"]public static void grep() {
StringBuilder sb = new StringBuilder();
try {
Files.lines(Path.of("T:\\test.txt"))
.filter(line -> line.matches(".*[0-9].*"))
.forEach(line -> sb.append(line).append("\n"));

Files.writeString(Path.of("T:\\test.filtered.txt"), sb.toString().trim());
} catch (IOException e) {
e.printStackTrace();
}
}[/CODE]

[CODE lang="java" title="grep to console"]public static void grepConsole() {
try {
Files.lines(Path.of("T:\\test.txt"))
.filter(line -> line.matches(".*[0-9].*"))
.forEach(System.out:rintln);
} catch (IOException e) {
e.printStackTrace();
}
}[/CODE]

 

[developer418]

Die Idee hat einen entscheidenden Nachteil: die Methode muss nun viele Annahmen über Quelle und Ziel treffen. Wie gibst Du dort z. B. die Standardausgabe, die Fehlerausgabe oder einen Teil des Speichers für die Ausgabe an?

Hier wäre die Nutzung ausschießlich von InputStream und OutputStreams eine Lösung.

// z.B. Console
grep(regex, ...., System.out)

// z.B. ByteArrayOutputStream für byte[]
ByteArrayOutputStream bOut;   
grep(regex, ...., bOut)

// z.B. FileOutputStream für Date
FileOutputStream fos;   
grep(regex, ...., fos)

static void grep(String regex, ...., OutputStream out) throws IOException {
   ...   
}

 

[kneitzel]

Das ist doch Code, der komplett an der Aufgabe vorbei geht:

Grep ist in der API so vorgegeben:

static void grep(java.lang.String regex, java.io.Reader reader, java.io.Writer writer)

Daher kann ich diese "Lösungsansätze" in keiner Weise nachvollziehen. Die eigentliche Lösung, die wichtig ist für den TE hat @mihe7 in #7 gegeben: Denn es fehlt schlicht daran, wie ein writer für die gegebene Methode grep erzeugt werden kann.

 

[kneitzel]

Also generell ist es egal, wie man die Aufgabe versteht:
a) Man nimmt die Parameter der main Methode als Eingabe.
b) Man liest den Befehl ein.

Bei letzterem muss man nur schauen, was denn das Ergebnis von diesem Code ist:

        String[] s1 = "$ java Grep pattern filein fileout".split(" ");
        String[] s2 = "$ java Grep pattern filein ".split(" ");

Es läuft immer auf das gleiche raus: Mal hat man ein Element mehr als bei der anderen Situation. Ob dies nun bei dem Parameter args ist oder bei einer lokalen Variable input, ist egal.

Bei b könnte man prüfen, ob die ersten Strings wirklich "$" "java" und "Grep" sind.
Aber generell hat man dann 2 oder 3 weitere Parameter.
Bei 3 Parametern hat man die 3 Argumente so wie sie der TE schon hat.
Bei 2 Argumenten ist der 3. Parameter ein Writer auf System.out.

 

[developer418]

Ok, dann habe ich das wohl missverstanden. 😅

Moin,
ich möchte ein Programm schreiben, welches den UNIX-Befehl grep nachstellt, [...]

Somit wollte ich auch Hinweise dazu geben, wie es allgemein einfacher gehen kann, wie z.B. die Nutzung von Streams in Java 11.
Ob und wie man diese nutzt, ist eine andere Frage.

 

[popeye2803]

Super, vielen Dank für eure Unterstützung.
Mit dem Lösungsansatz im Betrag #7 habe ich es hinbekommen.

 

[mihe7]

Dann könntest Du die Frage als beantwortet markieren, dann sieht man in der Übersicht gleich, dass hier nichts mehr "zu tun" ist.