java-8 - instream - stream parallel java 8

Modificar archivo usando Files.lines

Question

Me gustaría leer en un archivo y reemplazar un texto con texto nuevo. Sería simple usar asm e int 21h pero quiero usar las nuevas transmisiones de Java 8

    Files.write(outf.toPath(), 
        (Iterable<String>)Files.lines(inf)::iterator,
        CREATE, WRITE, TRUNCATE_EXISTING);

En algún lugar de allí, me gustaría un lines.replace("/*replace me*/","new Code()/n"); . Las nuevas líneas son porque quiero probar insertando un bloque de código en algún lugar.

Aquí hay un ejemplo de juego, que no funciona como quiero, pero que compila. Solo necesito una forma de interceptar las líneas del iterador y reemplazar ciertas frases con bloques de código.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import static java.nio.file.StandardOpenOption.*;
import java.util.Arrays;
import java.util.stream.Stream;

public class FileStreamTest {

    public static void main(String[] args) {
        String[] ss = new String[]{"hi","pls","help","me"};
        Stream<String> stream = Arrays.stream(ss);

        try {
            Files.write(Paths.get("tmp.txt"),
                    (Iterable<String>)stream::iterator,
                    CREATE, WRITE, TRUNCATE_EXISTING);
        } catch (IOException ex) {}

//// I''d like to hook this next part into Files.write part./////
        //reset stream
        stream = Arrays.stream(ss);
        Iterable<String> it = stream::iterator;
        //I''d like to replace some text before writing to the file
        for (String s : it){
            System.out.println(s.replace("me", "my/nreal/nname"));
        }
    }

}

Edición: he llegado hasta aquí y funciona. Estaba tratando con filtro y tal vez no es realmente necesario.

        Files.write(Paths.get("tmp.txt"),
                 (Iterable<String>)(stream.map((s) -> {
                    return s.replace("me", "my/nreal/nname");
                }))::iterator,
                CREATE, WRITE, TRUNCATE_EXISTING);

Answer 1

El Files.write(..., Iterable, ...) parece tentador aquí, pero convertir el Stream en un Iterable hace que esto sea engorroso. También se "extrae" del Iterable, que es un poco extraño. Tendría más sentido si el método de escritura de archivos pudiera usarse como la operación de terminal del flujo, dentro de algo como forEach .

Desafortunadamente, la mayoría de las cosas que escriben arrojan IOException , lo cual no está permitido por la interfaz funcional del Consumer que forEach espera. Pero PrintWriter es diferente. Al menos, sus métodos de escritura no lanzan excepciones comprobadas, aunque abrir una puede lanzar IOException . Así es como podría ser usado.

Stream<String> stream = ... ;
try (PrintWriter pw = new PrintWriter("output.txt", "UTF-8")) {
    stream.map(s -> s.replaceAll("foo", "bar"))
          .forEachOrdered(pw::println);
}

Tenga en cuenta el uso de forEachOrdered , que imprime las líneas de salida en el mismo orden en que se leyeron, lo que presumiblemente es lo que desea.

Si está leyendo líneas de un archivo de entrada, modificándolas y luego escribiéndolas en un archivo de salida, sería razonable colocar ambos archivos dentro de la misma declaración try-with-resources:

try (Stream<String> input = Files.lines(Paths.get("input.txt"));
     PrintWriter output = new PrintWriter("output.txt", "UTF-8"))
{
    input.map(s -> s.replaceAll("foo", "bar"))
         .forEachOrdered(output::println);
}