Autore Topic: Generare un file sul dispositivo  (Letto 691 volte)

Offline khyn

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
Generare un file sul dispositivo
« il: 30 Novembre 2011, 16:31:47 CET »
0
Ciao a tutti, credo di non aver individuato una sezione adatta a questo topic per cui ho scelto "altri problemi".

Sto scrivendo una classe java che, richiamata dall'Activity principale, mi generi un file  di un certo "peso" (nell'esempio 10MB).
La mia strategia di realizzazione prevede che venga creato un file vuoto, riempito poi da 1024*1024*10 caratteri (1 char = 1 bit ---> 10Megabyte).
Il codice che ho scritto funziona (tranne il metodo alternativo messo alla fine in commento), il problema però è che il file viene creato troppo lentamente!   o_O

Questo è il codice:

Codice (Java): [Seleziona]
import java.io.*;
import android.os.Environment;
import android.util.Log;

public class CreaFile {
               
                public void genFile(String PATH){
                        //Genero un file vuoto
                        File sdcardDir = Environment.getExternalStorageDirectory();
                        File f;
                        f = new File(sdcardDir, "File.txt");
                        if(!f.exists()){
                                try{
                                        f.createNewFile();
                                        Log.v(",", "Generazione file contenitore = " +f.exists());
                                }catch(IOException e){
                                        e.printStackTrace();
                                        Log.v(",", "Generazione file contenitore = " +f.exists());
                                       
                                }
                        }
               
                        try {
                                //Riempie il file di caratteri
                                Log.v(",", "Sono nel try che crea il file");
                                FileWriter w;
                                w = new FileWriter (f);
                                BufferedWriter b;
                                b = new BufferedWriter (w);
                                int dim = 1024*1024*10;
                                char val = 0;
                                //scrivo 1024*1024*10 byte = 10MB di caratteri
                                for (int d=0; d<=1024; d++) {
                                        val = (char)((int)(Math.random()*9));
                                }
                                for(int i=0; i<=dim; i++){
                                        //scrivo nel buffer
                                        b.write(val);
                                        if ((i != 0 && i % 1024 == 0)|| i==dim) {
                                                //scarico il contenuto nel file fisico
                                                b.flush();
                                                Log.v(",", i+" ho scaricato il buffer");
                                        }
                               
                                }
                                b.close();
                                w.close();
                               
                        }   catch (IOException e) {
                                e.printStackTrace();
                                Log.v(",", "Impossibile creare il file! " +e);
                        }
               
               
               
                //Metodo alternativo con stream continuativo
               
//              public void genStream(String PATH){
//                      try{
//                              FileOutputStream fStream = new FileOutputStream(PATH);
//                              DataOutputStream dStream = new DataOutputStream(fStream);
//                              char val;
//                              //ATTENZIONE: Il write dello stream usa 2 byte per char
//                              for(int i=0; i<(512*1024*10);i++){
//                                      val = (char)((int)(Math.random()*9));
//                                      dStream.writeChar(val);
//                              }
//                              //chiudo lo stream e il file
//                              dStream.close();
//                              fStream.close();
//                      }catch(IOException e){
//                              e.printStackTrace();
//                      }
               
                }
}

Mi serve dunque un'ottimizzazione che abbatta sensibilmente il tempo di creazione del file (attualmente circa un minuto)...  :-[
Suppongo che sia un problema banale, purtroppo con la programmazione Java ancora non me la cavo granché.   :'(



Offline Luigi.Arena

  • Utente senior
  • ****
  • Post: 616
  • DACIA DUSTER 4X4 SUPER
  • Respect: +56
    • Mostra profilo
    • ArenaWebTest
  • Dispositivo Android:
    epad m009
  • Play Store ID:
    Luigi Arena
  • Sistema operativo:
    Windows 7
Re:Generare un file sul dispositivo
« Risposta #1 il: 01 Dicembre 2011, 00:13:34 CET »
0
Solo per curiosità  :-P
A cosa ti serve questo ciclo ?
Codice: [Seleziona]
for (int d=0; d<=1024; d++) {
                                        val = (char)((int)(Math.random()*9));
                                }

Se non sono stordito data l'ora val sarà uguale ad un numero casuale,qual'è lo scopo della variabile d ?
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato .

Offline khyn

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
Re:Generare un file sul dispositivo
« Risposta #2 il: 01 Dicembre 2011, 01:04:47 CET »
0
Ciao Luigi, in realtà quel ciclo for fa parte delle prove di ottimizzazione che ho fatto... Il fine sarebbe quello di inviare 1024 caratteri casuali già "estratti".
Nell'ultima versione ho fatto in modo di trasformarli in una stringa, in questo modo:

Codice (Java): [Seleziona]
String val = "";
...
...
for (int d=0; d<=1024*10; d++) {
                                        val = val+(char)((int)(Math.random()*9));
                                }

Purtroppo i risultati, in termini di velocità, sono ancora insoddisfacenti. Inoltre, praticamente non variano testando il tutto su un device fisico (pensavo il simulatore fosse molto più lento ma a quanto pare mi sbagliavo).  :-\

Offline iceweasel

  • Moderatore globale
  • Utente senior
  • *****
  • Post: 878
  • Respect: +147
    • Mostra profilo
  • Dispositivo Android:
    LGE P990 - Google Nexus 5
  • Sistema operativo:
    Linux Debian Sid
Re:Generare un file sul dispositivo
« Risposta #3 il: 01 Dicembre 2011, 01:45:52 CET »
0
Ti dico subito che la concatenazione con l'operatore + di stringhe è lento, si usa la StringBuffer o lo StringBulder, per quello che devi fare è più veloce un array di caratteri.

Il metodo flush in un loop in scrittura rallenta parecchio e francamente non serve (anche il Log rallenta se attivo)

Scrivere singoli caratteri è sempre lento, per questo motivo che esiste la write di array:

BufferedWriter | Android Developers


adb logcat | tee /tmp/logcat | grep TAG