Ouverture d'un fichier texte 12kb prend trop longtemps ...?

Question

Le code suivant fonctionne, mais prend trop de temps (plus d'une minute) pour ouvrir un petit fichier. Les LogCat montre beaucoup de cas de « GC_FOR_MALLOC libérés des objets / ###### #### octets dans ## ms ». Toutes les suggestions?

 File dirPath = new File(Environment.getExternalStorageDirectory(), "MyFolder");
 String content = getFile("test.txt");

 public String getFile(String file){
  String content = "";
  try {
   File dirPathFile = new File(dirPath, file);
   FileInputStream fis = new FileInputStream(dirPathFile);
   int c;
   while((c = fis.read()) != -1) {
    content += (char)c;
   }
   fis.close();
  } catch (Exception e) {
   getLog("Error (" + e.toString() + ") with: " + file);
  }
  return content;
 }

Mise à jour:

Voici à quoi il ressemble maintenant:

File dirPath = new File(Environment.getExternalStorageDirectory(), "MyFolder");
String content = getFile("test.txt");

public String getFile(String file){
    String content = "";
    File dirPathFile = new File(dirPath, file);
    try {
        StringBuilder text = new StringBuilder();
        BufferedReader br = new BufferedReader(new FileReader(dirPathFile));
        String line;
        while ((line = br.readLine()) != null) {
            text.append(line);
            text.append('\n');
        }
        content = new String(text);
        } catch (Exception e) {
            getLog("Error (" + e.toString() + ") with: " + file);
    }
    return content;
}

Merci à vous tous !!

Answer 1

Utilisation += sur une chaîne est très inefficace - il sera constamment allouer et désallouer la mémoire, quelque chose que vous devez éviter

Si vous devez constamment ajouter des caractères, utilisez un StringBuilder et lui donner un tampon suffisamment grande à l'avant.

Cependant, il est encore mieux de lire le fichier entier comme un tableau d'octets, puis créer une chaîne à partir de ce tableau d'octets. Utilisez le constructeur de String(byte[]).

Answer 2

  

contenu + = (char) c;

Eh bien, voici votre problème. concaténation de chaîne est lent si vous devez le faire à plusieurs reprises. Et vous lisez le fichier un caractère à la fois, ce qui est vraiment lent.

Vous voulez être en utilisant la méthode de read(byte[] buffer) pour lire le fichier dans un tampon efficace. Et puis vous pouvez stringify le tampon en cas de besoin.

Answer 3

Plutôt que de lire un seul octet à la fois, vous devriez lire à l'aide multiple read (byte []) .

En outre, les chaînes sont immuables, donc chaque fois que vous faites chaîne s s = + "a"; il y a la possibilité que vous créez un nouvel objet String. Vous pouvez utiliser StringBuilder au lieu de construire une chaîne plus grande.

Answer 4

Schlemiel le peintre frappe à nouveau!

Answer 5

essayez de lire avec un tampon lecture (byte [] chamois)

Answer 6

Les raisons sont les suivantes:

1. Vous créez un trop grand nombre d'objets à cordes avec content += (char)c; -. Utiliser StringBuilder au lieu d'ajouter des données lues, puis sur le StringBuilder dans l'appel final toString ()
2. Vous n'utilisez un octet [] (ou char [], il dépend de la mise en œuvre) tampon pour lire le fichier. Habituellement, un tampon 1KB est optimale au lieu de lire un par un octet.