[JAVA]: Leggere linee di informazioni da file e interpretarle/convertirle

[perzem]

si quella è la base per i file zip
poi trovi qualcosa qui per la decompressione
http://javaalmanac.com/egs/java.util...Zip.html?l=rel

una volta decompressi e salvati li puoi leggere tranquillamente con i metodi che ho postato prima...

se nn possiamo sapere a priori quando termina un insieme di numeri e ne inizia un altro e se nn vi è alcuna differenza tra gli elementi di un blocco e l'altro è davvero difficile fare una divisione tra i vari array, se non impossibile. Sei sicura che tutto questo è vero???

[I_love_Italy]

Originariamente inviato da perzem
si quella è la base per i file zip
poi trovi qualcosa qui per la decompressione
http://javaalmanac.com/egs/java.util...Zip.html?l=rel

una volta decompressi e salvati li puoi leggere tranquillamente con i metodi che ho postato prima...

se nn possiamo sapere a priori quando termina un insieme di numeri e ne inizia un altro e se nn vi è alcuna differenza tra gli elementi di un blocco e l'altro è davvero difficile fare una divisione tra i vari array, se non impossibile. Sei sicura che tutto questo è vero???

Grazie per il link, appena posso lo controllo...
Forse non mi ero spiegata bene, ma finora in tutti i file che ho controllato si capisce dove stacca una categoria e dove comincia l'altra perchè va a capo, infatti, volendo correggere il mio post iniziale, la struttura è del tipo:

111 111 111 111
111 111 111 111
...
111 111
222 222 222 222 222 222
222 222 222 222 222 222
...
222 222
333 333 333 333 333 333
333 333 333 333 333 333
...
333 333

Però in alcuni file che hanno un numero di punti diverso è così:

111 111 111 111
111 111 111 111
...
111
222 222 222 222 222 222
222 222 222 222 222 222
...
222
333 333 333 333 333 333
333 333 333 333 333 333
...
333

ma non so gli altri, perchè il numero di punti non è uguale per tutti i file. Tuttavia la cosa interessante che ho notato è che la categoria due inizia con dei valori tipo 0.00000e+00, idem per la 3, cosa che presumo sia uguale per tutti i file ma non ne sono sicura (non posso controllarmi più di 20Gb di file, per di più zippati!!!). Magari spiegare la struttura del file è un pò difficile, al max posso spedirtelo via mail così magari lo capisci meglio di come l'ho spiegato io.

[maurizio2]

Purtroppo su questo non ti posso aiutare tanto, non ho mai utilizzato mai quel package..
Io lo scompatto con un altro programma tipo WinZip o WinRar e vedo come leggere i dati, poi vediamo come effettuare la scompattazione nel codice java.

[perzem]

la soluzione per differenziare tra il primo e il secondo blocco e già il fatto che il primo ha 4 el per riga mentre il secondo 6 quindi basta controllare il numero di token per riga e quando ne troviamo 6 si passa al nuovo array.
ho notato nel file che hai postato che i numeri prima della virgola sono in ordine crescente e che quando si passa ad un altro blocco ricominciano da 0, quindi quando troviamo una riga che inizia con una serie di numeri che iniziano con uno 0 prima della virgola passiamo ad un nuovo array... è corretta questa osservazione??

Possiamo anche decomprimere questi files,il seguente programma prende tutti i .zip della directory dove viene eseguito e li decomprime.

import java.util.*;
import java.util.zip.*;
import java.io.*;

public class Decomp
{
public static void main(String [] a)
{
File dir=new File(".");
System.out.println("Apro la directory "+dir.getAbsolutePath());
File[] cont=dir.listFiles();
int MAX=cont.length;
for (int i = 0; i<MAX; i++)
{
String tmp=cont[i].getName();
if ((tmp.endsWith(".zip"))||(tmp.endsWith(".ZIP")))
{
// è un file .zip
System.out.println("Ho trovato "+tmp);
try {controllaZip(cont[i]);}
catch (IOException e){};
};
}
}
public static void controllaZip(File f) throws IOException
{
System.out.println("Decompressione del file "+f.getName()+":");
ZipFile Zf;
try {Zf=new ZipFile(f);}
catch (ZipException e){Zf=null;}
catch (IOException e1){Zf=null;}
;
Enumeration files=Zf.entries();
while(files.hasMoreElements())
{
ZipEntry tmpFile=(ZipEntry ) files.nextElement();
System.out.println("decomprimo il file "+tmpFile.getName());
System.out.println("dimensione compresso "+
tmpFile.getCompressedsize()+" dimensione non compresso "+
tmpFile.getsize()+" CRC "+tmpFile.getCrc());
System.out.println("modificato "+tmpFile.getTime());
InputStream in= Zf.getInputStream(tmpFile);
FileOutputStream out= new FileOutputStream(tmpFile.getName());

for (int ch=in.read();ch!=-1;ch=in.read()) out.write(ch);

out.close();
in.close();
}
}
}

[I_love_Italy]

Originariamente inviato da perzem
ho notato nel file che hai postato che i numeri prima della virgola sono in ordine crescente e che quando si passa ad un altro blocco ricominciano da 0, quindi quando troviamo una riga che inizia con una serie di numeri che iniziano con uno 0 prima della virgola passiamo ad un nuovo array... è corretta questa osservazione??

Si la tua osservazione è corretta, il fatto che siano decrescenti potrebbe venirmi in aiuto. Cmq ti ho mandato un msg privato col link di dove puoi trovare il file, così ti fai convinto da solo.
Un grazie immenso.

[I_love_Italy]

Avevo pensato la seguente cosa, però non so se è possibile farla...

Visto che a priori so di quanto deve essere grande ciascun array grazie al mio 4° numeretto, non si può fare in modo che appena l'array arrivi a tale dimensione (nel mio caso 52790) si passi a memorizzare nell'altro array e così via finchè non finisce il file? Questo metodo potrebbe andare bene per qualsiasi tipo di file, a prescindere dal numero di token per riga. Tuttavia non so se è una operazione che è possibile fare visto che non sono un'esperta nè di array nè di lettura da file!
Oppure, qualora ogni categoria cambi portando a capo, si potrebbero contare i token di quest'ultima riga e se sono < di 4 nel primo caso e di 6 nel secondo passare al secondo array... Però se ci fosse un file che ha tutte le righe riempite fino a 4 o 6 colonne sarebbe un problema!

[perzem]

Visto che a priori so di quanto deve essere grande ciascun array grazie al mio 4° numeretto, non si può fare in modo che appena l'array arrivi a tale dimensione (nel mio caso 52790) si passi a memorizzare nell'altro array e così via finchè non finisce il file

ma tu avevi detto che quel numero rappresentava il numero totale di el, cioè la somma di tutte le 3 categorie. Se invece rappresenta il numero di el per categoria, basta che usi un contatore e quando questo raggiunge la soglia lo azzeri passi ad un nuovo array e ricominci

Dalla terza riga in poi compaiono i valori che mi interessano divisi in tre categorie che si susseguono (cioè se ho 99 valori avrò 33 valori categoria a, 33 valori cat b e 33 cat c).

dato che nell'ultima riga di ogni categoria ci possono essere meno di 4 o 6 elementi, secondo me la via migliore è dire finche ogni il primo numero di ogni elemento è maggiore del precendente copio nello stesso array, quando ne trovo uno minore passo ad un array nuovo.

[I_love_Italy]

ma tu avevi detto che quel numero rappresentava il numero totale di el, cioè la somma di tutte le 3 categorie. Se invece rappresenta il numero di el per categoria, basta che usi un contatore e quando questo raggiunge la soglia lo azzeri passi ad un nuovo array e ricominci

Ehm, forse mi ero espressa male... scusatemi tutti per l'incomprensione (sono una deficiente)...
Ricomincio: chiamo d'ora in poi count=52790(o qualsiasi altro numero diverso da file a file) che è il numero di elementi di ogni categoria, quindi count x3=numero elementi totali dalla terza riga in poi.

dato che nell'ultima riga di ogni categoria ci possono essere meno di 4 o 6 elementi, secondo me la via migliore è dire finche ogni il primo numero di ogni elemento è maggiore del precendente copio nello stesso array, quando ne trovo uno minore passo ad un array nuovo.

Ma non è meglio azzerare il contatore di volta in volta? Così evito di trovarmi nella spiacevole condizione in cui, se per caso count è perfettamente divisibile per 6 e per 4, di avere l'ultima riga di ogni categoria piena. Inoltre non è detto che il primo numero di ogni elemento sia maggiore del precendente, questa cosa l'avevo già scartata a priori guardando attenatamente il file (cmq anche io avevo avuto il tuo stesso pensiero). Come dicevo nel precedente mio post, pensavo che non si potesse fare una operazione simile perchè avevo capito che ogni volta che viene letta una riga vengono contati i token solo di quella riga e non di tutto il file. Se così non fosse si può passare all'altro array se count=n° token_per_categoria, o sbaglio? Ma che costrutto conviene usare in questo caso? Avevo letto dell'esistenza di arraylist, può giovarmi?

[perzem]

si ora che hai chiarito il dilemma il contantore è la soluzione esatta...

Come dicevo nel precedente mio post, pensavo che non si potesse fare una operazione simile perchè avevo capito che ogni volta che viene letta una riga vengono contati i token solo di quella riga e non di tutto il file

si hai ragione il metodo esistente nel tokenizer con i token di solo quella riga.. Per il tuo caso basta che dichiari una variabile intero e la incrementi ogni volta che leggi un token, così arriverai al max di el senza problemi

[I_love_Italy]

Ho capito, ma conviene utilizzare arraylist? O serve per creare un array di righe? Stavo guardando il link dell'altra discussione che mi avevi indicato, ma sono più confusa che persuasa...
In un forum avevo trovato questo:

public String getLine(int i, File f){
Scanner sc = new Scanner(f);
for(int j = 0 ; j< i-1 ; j++){
sc.readLine();
}
return sc.readLine();
}

può essermi d'aiuto?