Existe-t-il un moyen de rendre la sortie PrintWriter au format UNIX?

Question

En Java, bien sûr. J'écris un programme et je l'exécute sous un environnement Windows, mais j'ai besoin que la sortie (.csv) soit faite au format Unix. Une solution facile? Merci!

Answer 1

Par "format Unix", voulez-vous dire "\ n" comme terminaison de ligne au lieu de "\ r \ n"? Définissez simplement la propriété système line.separator avant de créer le PrintWriter.

Tout comme une démonstration:

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(); 
    } 
} 

Bien sûr qu'il fixe pour la machine virtuelle Java ensemble, ce qui est pas idéal, mais il peut être tout ce que vous arrive d'avoir besoin.

Answer 2

En supposant que la question de formatage vous faites référence à est que les sauts de ligne Windows sont transport RSS retour ligne ("\r\n") tandis que les Unix sont ligne Feed ("\n") seulement, la meilleure façon de vous assurer que votre fichier utilise LF et non CRLF est pour éviter println et à la place utiliser print("\n") pour terminer les lignes.

Ainsi, au lieu de:

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

utilisation

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

Vous pouvez simplement rechercher les fichiers pertinents pour println pour vous assurer que vous les attraper tous.

Answer 3

Un programmeur paranoïaque se synchroniserait sur l'objet de propriétés système, au moins si différents Printwriters avaient besoin de différents types de terminaisons de ligne.

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

Pour écrire un fichier avec les fins de ligne unix, substituez println dans une classe dérivée de PrintWriter et d'imprimer, avec \ 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(); 

Ceci évite d'avoir à toucher les appels println existants dans votre code.

Answer 5

Je vois 2 autres options qui n'affectent pas le système entier ou qui mènent à des problèmes de simultanéité comme le réglage du lineSeparator. Je voudrais également déclarer une énumération qui représente les fins de ligne.

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

    private String lineSeparator; 

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

    public String getLineSeparator() { 
    return lineSeparator; 
    } 
} 

1. Réglez le lineSeperator utilisant la réflexion.

   Vous devez créer une fabrique qui encapsule l'accès à l'aide de la réflexion pour masquer les composants internes PrintWriter des clients. Par exemple. code client devrait ressembler à ceci:

   PrintWriterFactory.newPrintWriter(someWriter, LineEnding.UNIX); 
   

   Alors que la mise en œuvre pourrait ressembler à ceci:

   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: L'usine ne doit pas être statique. Vous pouvez utiliser une interface et plusieurs implémentations si l'implémentation PrintWriter passe d'un JDK à un autre et vous devez donc utiliser une autre stratégie de réflexion.

2. Étendre PrintWriter et remplacer la méthode 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(); 
       } 
       } 
   }