JavaFX Mit Stream-API (1.8) in Textdatei schreiben

[Phoenixz]

Abend,

hab da ein kleines Problem. Ich habe eine ArrayList mit verschiedenen Strings, möchte davon aber nur die ersten 10 ausgeben. Anschließend möchte ich diese in eine Textdatei schreiben.
Dies möchte ich alles mit Hilfe des Interface

Stream<T>

und Lambda-Ausdrücken schaffen (falls dies möglich ist):

FileWriter fwriter = new FileWriter("stream.txt");
//Füllen
ArrayList<Integer> strings = new ArrayList<>();
for (int i = 0; i < 100; i++) {
	    	strings.add("nummer" + String.valueOf(i));
}

Stream<String> stream1 = strings.stream().limit(10);
stream1.forEach(w -> fwriter.write(w)); // hier gibt es eine Errormeldung s.u.

fwriter.close();

Folgende Errormeldung taucht auf:
"Exception in thread "main" java.lang.Error: Unresolved compilation problem:
Unhandled exception type IOException"

Try-catch-Block bringt nichts (Vorschlag des Compilers), was mache ich falsch?

 

[nvidia]

Der Lambda-Ausdruck ist das Problem. Die write()-Methode wirft eine checked Exception, IOException in diesem Fall, und diese wird vom umgebenden Kontext, dem Stream, nicht verarbeitet. D.h. die Exception muss also direkt im Lambda-Ausdruck behandelt werden. Das ist relativ unschön, aber gehört mit zu den "Trade-Offs" die getroffen worden sind. Vll. verbessert sich da etwas in den kommenden Java-Versionen. Jedenfalls müsste der Code ungefähr wie folgt aussehen.

stream1.forEach(w -> {
            try {
                fwriter.write(w);
            } catch (IOException e) {
                throw UncheckedIOException::new;
            }
        });

 

[Ruzmanz]

Ich persönlich lagere die Methoden gerne aus, damit man die Debuggen kann und der Quelltext leserlicher wird. Hättest du da einen Einwand nvidia?

public class IDontKnow {  
	FileWriter fwriter;

    public IDontKnow() {
    	List<String> s = Arrays.asList(new String[]{"a", "b", "c", "d"});
        s.forEach(this::appendToFile);
        // == s.forEach(text -> appendToFile(text));
    }
    
    private void appendToFile(String text) {
    	try {
    		fwriter.write(text);
    	} catch(IOException ex) {
    		throw new UncheckedIOException(ex);
    	}
    }
}

 

[nvidia]

Hm, naja, bei so kurzen Ausdrücken ist das Geschmackssache, kann man tun, muss man nicht. Und eigentlich will man etwas leicht anderes, und zwar die Funktionalität zwischen dem try-catch abstrahieren. Angenommen wir bleiben bei deinem Beispiel und bekommen von irgendwoher einen FileWriter. Dann könnte die erste Maßnahme wie folgt aussehen:

 public class IDontKnow {
        @FunctionalInterface
        private interface ConsumerWithEx<T> {
            void accept(T t) throws Exception;
        }

        FileWriter fwriter;

        private static <T> Consumer<T> toUnchecked(ConsumerWithEx<T> consumer){
            return (T arg) -> {
                try {
                    consumer.accept(arg);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } catch (Throwable t){
                    throw t;
                }
            };
        }

        public IDontKnow() {
            Consumer<String> appendToFile = toUnchecked(fwriter::write);
            Arrays
                .stream(new String[]{"a", "b", "c", "d"})
                .forEach(appendToFile::accept);
        }
    }

Und falls wirklich noch mehr hinzukommt als nur das Schreiben der Zeile, vll. eine Validierung etc. kann man dann so wie du eine weitere Methode einführen.

        public IDontKnow() {
            //Consumer<String> appendToFile = toUnchecked(fwriter::write);
            Consumer<String> appendToFile = toUnchecked(this::appendToFile);
            Arrays
                .stream(new String[]{"a", "b", "c", "d"})
                .forEach(appendToFile::accept);
        }

        private void appendToFile(String text) throws IOException {
            //mach dies
            fwriter.write(text);
            //mach jenes
        }

Aber man sieht das bei der Verwendung von Lambda-Ausdrücken darauf geachtet werden sollte das keine checked Exceptions verwendet werden, es ist einfach hakelig und unschön.