Formattazione file di output

[Poncherello]

Ciao a tutti,
ho necessità di stampare delle righe su un file di output, ma vorrei il file di output sia formattato in modo che le varie colonne siano allineate. Ho provato ad usare i "\t" ma il risultato non è stato un granchè, qualcuno ha qualche idea?

[LeleFT]

Il carattere \t (ovvero la tabulazione) è un carattere "particolare": visivamente i vari campi possono non essere allineati (dipende sempre dall'ampiezza visiva di tale carattere e dalla quantità di dati che ci sono nella colonna "precedente". E' ottimo per permettere una corretta separazione delle colonne per diversi automatismi (da Excel ai vari programmi che interpretano dati con tracciati definiti, ecc).

Se il tuo scopo è ottenere un allineamento "visivo" (nel senso che se lo apri col blocco note, ad esempio, le colonne sono ben allineate) allora l'unico carattere che ha senso usare è lo spazio singolo (che rappresenta la più piccola unità come carattere) e devi effettuare tu tutti i calcoli necessari: devi, cioè, sapere a priori (prima di iniziare a scrivere il file) quale sarà la larghezza di ciascuna colonna (quindi, devi conoscere esattamente il numero di caratteri di cui è composto il campo di lunghezza massima di una specifica colonna), quindi scrivere "fillando" di spazi dove necessario.

Non è un'operazione "banale" perchè richiede di scorrere 2 volte tutti i dati da scrivere: la prima volta per ottenere il numero massimo di caratteri di ciascuna colonna, la seconda volta per la scrittura effettiva su file.

Sto, ovviamente, prendendo in esame i file di testo puri: se il tuo obiettivo può essere raggiunto anche creando un file HTML, le cose diventano molto più semplici, ma a questo punto si parla di ipertesti e non di file di testo.


Ciao.

[Poncherello]

Il carattere \t (ovvero la tabulazione) è un carattere "particolare": visivamente i vari campi possono non essere allineati (dipende sempre dall'ampiezza visiva di tale carattere e dalla quantità di dati che ci sono nella colonna "precedente". E' ottimo per permettere una corretta separazione delle colonne per diversi automatismi (da Excel ai vari programmi che interpretano dati con tracciati definiti, ecc).

Se il tuo scopo è ottenere un allineamento "visivo" (nel senso che se lo apri col blocco note, ad esempio, le colonne sono ben allineate) allora l'unico carattere che ha senso usare è lo spazio singolo (che rappresenta la più piccola unità come carattere) e devi effettuare tu tutti i calcoli necessari: devi, cioè, sapere a priori (prima di iniziare a scrivere il file) quale sarà la larghezza di ciascuna colonna (quindi, devi conoscere esattamente il numero di caratteri di cui è composto il campo di lunghezza massima di una specifica colonna), quindi scrivere "fillando" di spazi dove necessario.

Non è un'operazione "banale" perchè richiede di scorrere 2 volte tutti i dati da scrivere: la prima volta per ottenere il numero massimo di caratteri di ciascuna colonna, la seconda volta per la scrittura effettiva su file.

Sto, ovviamente, prendendo in esame i file di testo puri: se il tuo obiettivo può essere raggiunto anche creando un file HTML, le cose diventano molto più semplici, ma a questo punto si parla di ipertesti e non di file di testo.


Ciao.

Ciao,
grazie mille della risposta. Mi serviva un metodo più veloce, anche perchè nel file di testo devo inserire un milione di elementi e farlo per tutti diventa troppo pesante

[andbin]

Mi serviva un metodo più veloce, anche perchè nel file di testo devo inserire un milione di elementi e farlo per tutti diventa troppo pesante

Purtroppo non è una cosa che si può intendere "veloce". LeleFT è stato chiarissimo:

devi effettuare tu tutti i calcoli necessari

richiede di scorrere 2 volte tutti i dati da scrivere: la prima volta per ottenere il numero massimo di caratteri di ciascuna colonna, la seconda volta per la scrittura effettiva su file

Qualcosa lo puoi sicuramente generalizzare ... ma lo devi "intravedere" tu secondo la architettura della tua applicazione.

[LeleFT]

Questa è una classettina che mi scrissi un po' di tempo fa per fare proprio sta roba.
Ovviamente me l'ero scritta per me, quindi non è sufficientemente fault-tolerant (ad esempio, ciascuna "riga" deve obbligatoriamente avere lo stesso numero di colonne, altrimenti s'arrabbia).

Fa il suo sporco lavoro e per quantità di dati non esagerate è anche abbastanza veloce.

public class IncolonnaSuFile {

   public static void scriviFile(File fileOutput, List<String[]> dati, int spaziaturaColonne) throws IOException {
      if ((dati != null) && !dati.isEmpty()) {
         // Preparo la spaziatura tra le colonne
         StringBuilder spaziatura = new StringBuilder();
         while(spaziatura.length() < spaziaturaColonne) spaziatura.append(' ');

         FileWriter fw = null;
         BufferedWriter bw = null;
         PrintWriter pw = null;
         try {
            fw = new FileWriter( fileOutput );
            bw = new BufferedWriter( fw );
            pw = new PrintWriter( bw );

            // Scorro tutti i dati per calcolare le dimensioni delle colonne
            int[] columnWidth = calcolaDimensioneColonne( dati );

            // Ora scorro nuovamente i dati per scrivere il file
            StringBuilder sbRiga = new StringBuilder();
            for(String[] riga : dati) {
               for(int i=0; i<riga.length; i++) {
                  sbRiga.append( fill(riga[i], columnWidth[i]) ).append( spaziatura.toString() );
               }

               pw.println( sbRiga.toString() );
               sbRiga.setLength( 0 );
            }

            pw.flush();
         } finally {
            if (pw != null) {
               try { pw.close(); } catch (Exception e) { }
            } else {
               if (bw != null) {
                  try { bw.close(); } catch (Exception e) { }
               } else {
                  if (fw != null) {
                     try { fw.close(); } catch (Exception e) { }
                  }
               }
            }
         }
      } else {
         // Se non ho nulla da scrivere, creo un file vuoto
         fileOutput.createNewFile();
      }
   }

   private static int[] calcolaDimensioneColonne(List<String[]> dati) {
      int[] ret = new int[ dati.get(0).length ];

      for(String[] riga : dati) {
         for(int i=0; i<riga.length; i++) {
            if (riga[i].length() > ret[i]) ret[i] = riga[i].length();
         }
      }

      return ret;
   }

   private static String fill(String dato, int length) {
      StringBuilder sb = new StringBuilder( dato );
      while(sb.length() < length) sb.append(' ');
      return sb.toString();
   }

}

Il primo parametro del (unico) metodo pubblico è il File da creare.
Il secondo parametro è la lista di "righe" da scrivere: ciascuna riga è un array (quindi, un elenco di colonne)
Il terzo parametro è un intero che indica il numero di spazi di separazione tra una colonna e l'altra

Esempietti d'uso:

// Ho i miei dati come lista di array di stringhe
List<String[]> dati = ...;

// Scrivo su un file con 1 spazio di separazione tra le colonne
try {
   IncolonnaSuFile.scriviFile(new File("primoFile.txt"), dati, 1);
} catch (Exception e) {
   e.printStackTrace();
}

// Scrivo su un file con 3 spazi di separazione tra le colonne
try {
   IncolonnaSuFile.scriviFile(new File("secondoFile.txt"), dati, 3);
} catch (Exception e) {
   e.printStackTrace();
}
...

Ciao.