¿Hay alguna manera de hacer que la salida de PrintWriter sea en formato UNIX?

Question

En Java, por supuesto. Estoy escribiendo un programa y ejecutándolo en un entorno Windows, pero necesito que la salida (.csv) se realice en formato Unix. ¿Alguna solución fácil? ¡Gracias!

Answer 1

Por "formato Unix" ¿quiere decir usar "\ n" como el terminador de línea en lugar de "\ r \ n"? Simplemente configure la propiedad del sistema line.separator antes de crear el PrintWriter.

Así como una demostración:

import java.io.*; 

public class Test 
{ 
    public static void main(String[] args) 
     throws Exception // Just for simplicity 
    { 
     System.setProperty("line.separator", "xxx"); 
     PrintWriter pw = new PrintWriter(System.out); 
     pw.println("foo"); 
     pw.println("bar"); 
     pw.flush(); 
    } 
} 

Por supuesto que establece que para toda la JVM, que no es lo ideal, pero puede ser todo lo que sucede necesitar.

Answer 2

Suponiendo que el problema de formato que se refieren a es que los saltos de línea de Windows son de carro y avance de línea de retorno ("\r\n"), mientras que los de Unix son salto de línea ("\n") solamente, la forma más fácil de asegurarse de que su archivo utiliza LF, y CRLF es para evitar println y en su lugar usar print("\n") para terminar líneas.

Así que en lugar de:

writer.println("foo,bar,88"); 

uso

writer.print("foo,bar,88\n"); 

Usted puede simplemente buscar en los archivos pertinentes para println para asegurarse de que todos ellos captura.

Answer 3

Un programador paranoico se sincronizaría en el objeto de propiedades del sistema, al menos si diferentes Printwriters necesitan diferentes tipos de terminadores de línea.

public static PrintWriter createPrintWriter(OutputStreamWriter out, boolean autoflush){ 
    Properties props = System.getProperties(); 
    synchronized (props) { 
     Object old = null; 
     try { 
     old = props.setProperty("line.separator", "\n"); 
     return new PrintWriter(out, autoflush); 
     } finally { 
      if(old != null) { 
       props.put("line.separator", old); 
      } 
     } 
    } 
} 

Answer 4

Para escribir un archivo con los finales de línea Unix, anulan println en una clase derivada de PrintStream, y el uso de impresión con \ n.

PrintWriter out = new PrintWriter("testFile") { 
    @Override 
    public void println() { 
     write('\n'); 
    } 
}; 
out.println("This file will always have unix line endings"); 
out.println(41); 
out.close(); 

Esto evita tener que tocar ninguna println llamadas existentes que tiene en su código.

Answer 5

Veo 2 opciones más que no afectan a todo el sistema ni conducen a los valores de concurrencia como configurar el lineSeparator. También declararía una enumeración que representa los finales de línea.

enum LineEnding { 
    UNIX("\n"), DOS("\r\n"); 

    private String lineSeparator; 

    LineEnding(String lineSeparator) { 
    this.lineSeparator = lineSeparator; 
    } 

    public String getLineSeparator() { 
    return lineSeparator; 
    } 
} 

1. Establecer la lineSeperator utilizando la reflexión.

   Debe crear una fábrica que encapsule el acceso utilizando reflejo para ocultar las partes internas de PrintWriter de los clientes. P.ej. código de cliente debe tener este aspecto:

   PrintWriterFactory.newPrintWriter(someWriter, LineEnding.UNIX); 
   

   Mientras que la aplicación podría tener este aspecto:

   public class PrintWriterFactory { 
   
       private static final Field lineSeparatorField; 
   
       static { 
       try { 
        lineSeparatorField = PrintWriter.class.getDeclaredField("lineSeparator"); 
        lineSeparatorField.setAccessible(true); 
       } catch (NoSuchFieldException e) { 
        throw new IllegalStateException("java.io.PrintWriter implementation changed. Unable to determine lineSeparator field.", e); 
       } 
       } 
   
       public static PrintWriter newPrintWriter(Writer writer, LineEnding lineEnding) { 
       PrintWriter printWriter = new PrintWriter(writer); 
   
       try { 
        lineSeparatorField.set(printWriter, lineEnding.getLineSeparator()); 
       } catch (IllegalAccessException e) { 
        throw new IllegalStateException("Can't set line ending", e); 
       } 
   
       return printWriter; 
       } 
   } 
   

   PS: La fábrica no debe ser estática. Puede utilizar una interfaz y varias implementaciones si la implementación de PrintWriter cambia de un JDK a otro y, por lo tanto, debe usar otra estrategia de reflexión.

2. Extender PrintStream y sobrescribir el método println()

   public class LineEndingPrintWriter extends PrintWriter { 
   
       protected boolean autoFlush = false; 
       private LineEnding lineEnding; 
   
       public LineEndingPrintWriter(Writer out, LineEnding lineEnding) { 
       this(out, false, lineEnding); 
       } 
   
       public LineEndingPrintWriter(Writer out, boolean autoFlush, LineEnding lineEnding) { 
       super(out, autoFlush); 
       this.autoFlush = autoFlush; 
       this.lineEnding = lineEnding; 
       } 
   
       public LineEndingPrintWriter(OutputStream out, LineEnding lineEnding) { 
       this(out, false, lineEnding); 
       } 
   
       public LineEndingPrintWriter(OutputStream out, boolean autoFlush, LineEnding lineEnding) { 
       super(out, autoFlush); 
       this.autoFlush = autoFlush; 
       this.lineEnding = lineEnding; 
       } 
   
       protected void ensureOpen() throws IOException { 
       if (out == null) 
        throw new IOException("Stream closed"); 
       } 
   
       public void println() { 
       // Method body taken from java.io.PrintWriter.println(); 
       try { 
        synchronized (lock) { 
        ensureOpen(); 
   
        out.write(lineEnding.getLineSeparator()); 
   
        if (autoFlush) { 
         out.flush(); 
        } 
        } 
       } catch (InterruptedIOException e) { 
        Thread.currentThread().interrupt(); 
       } catch (IOException e) { 
        setError(); 
       } 
       } 
   }