Lire un simple fichier texte


115

J'essaie de lire un simple fichier texte dans mon exemple d'application Android. J'utilise le code écrit ci-dessous pour lire le fichier texte simple.

InputStream inputStream = openFileInput("test.txt");
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

Ma question est: Où dois-je placer ce "test.txt"fichier dans mon projet?. J'ai essayé de placer le fichier sous "res/raw"et le "asset"dossier mais j'obtiens le exception "FileNotFound"moment où le code écrit ci-dessus est exécuté pour la première fois.

Merci pour l'aide

Réponses:


181

Placez votre fichier texte dans le /assetsrépertoire sous le projet Android. Utilisez la AssetManagerclasse pour y accéder.

AssetManager am = context.getAssets();
InputStream is = am.open("test.txt");

Ou vous pouvez également placer le fichier dans le /res/rawrépertoire, où le fichier sera indexé et est accessible par un identifiant dans le fichier R:

InputStream is = context.getResources().openRawResource(R.raw.test);

9
S'interroge sur la différence de performance entre ces deux méthodes et un benchmark rapide n'a montré aucune différence appréciable.
Reuben L.

Quelle est la taille du fichier texte utilisé pour les tests de référence et avez-vous mis des images et d'autres ressources dans votre dossier res qui simule une application Android en temps réel (commerciale / gratuite)?
Sree Rama

2
Je n'ai pas de dossier "asset" dans mon application "hello world". Dois-je créer manuellement?
Kaushik Lele

2
Btw, le répertoire /assetsdoit être ajouté manuellement à partir d'Android Studio 1.2.2. Il devrait entrer src/main.
Jpaji Rajnish

3
Pour ceux comme @KaushikLele, qui se demandent comment ils peuvent obtenir le contexte; c'est facile. Dans une activité, vous pouvez simplement l'obtenir en utilisant le mot-clé "this" ou en appelant la méthode "getCurrentContext ()".
Alex

25

essaye ça,

package example.txtRead;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class txtRead extends Activity {
    String labels="caption";
    String text="";
    String[] s;
    private Vector<String> wordss;
    int j=0;
    private StringTokenizer tokenizer;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        wordss = new Vector<String>();
        TextView helloTxt = (TextView)findViewById(R.id.hellotxt);
        helloTxt.setText(readTxt());
 }

    private String readTxt(){

     InputStream inputStream = getResources().openRawResource(R.raw.toc);
//     InputStream inputStream = getResources().openRawResource(R.raw.internals);
     System.out.println(inputStream);
     ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

     int i;
  try {
   i = inputStream.read();
   while (i != -1)
      {
       byteArrayOutputStream.write(i);
       i = inputStream.read();
      }
      inputStream.close();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

     return byteArrayOutputStream.toString();
    }
}

23

Voici comment je fais:

public static String readFromAssets(Context context, String filename) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(context.getAssets().open(filename)));

    // do reading, usually loop until end of file reading  
    StringBuilder sb = new StringBuilder();
    String mLine = reader.readLine();
    while (mLine != null) {
        sb.append(mLine); // process line
        mLine = reader.readLine();
    }
    reader.close();
    return sb.toString();
}

utilisez-le comme suit:

readFromAssets(context,"test.txt")

1
Il peut être utile de spécifier le codage du fichier, par exemple "UTF-8" comme deuxième paramètre dans le constructeur InputStreamReader.
Makalele

7

Avoir un fichier dans votre assetsdossier vous oblige à utiliser ce morceau de code afin d'obtenir des fichiers du assetsdossier:

yourContext.getAssets().open("test.txt");

Dans cet exemple, getAssets()renvoie une AssetManagerinstance et vous êtes libre d'utiliser la méthode de votre choix à partir de l' AssetManagerAPI.


5

En mono pour Android ....

try
{
    System.IO.Stream StrIn = this.Assets.Open("MyMessage.txt");
    string Content = string.Empty;
    using (System.IO.StreamReader StrRead = new System.IO.StreamReader(StrIn))
    {
      try
      {
            Content = StrRead.ReadToEnd();
            StrRead.Close();
      }  
      catch (Exception ex) { csFunciones.MostarMsg(this, ex.Message); }
      }
          StrIn.Close();
          StrIn = null;
}
catch (Exception ex) { csFunciones.MostarMsg(this, ex.Message); }

3

Pour lire le fichier enregistré dans le dossier des actifs

public static String readFromFile(Context context, String file) {
        try {
            InputStream is = context.getAssets().open(file);
            int size = is.available();
            byte buffer[] = new byte[size];
            is.read(buffer);
            is.close();
            return new String(buffer);
        } catch (Exception e) {
            e.printStackTrace();
            return "" ;
        }
    }

1
"est disponible();" n'est pas sûr. Utilisez AssetFileDescriptor fd = getAssets (). OpenFd (fileName); taille int = (int) fd.getLength (); fd.close ();
GBY

0

Voici une classe simple qui gère à la fois rawet les assetfichiers:

classe publique ReadFromFile {

public static String raw(Context context, @RawRes int id) {
    InputStream is = context.getResources().openRawResource(id);
    int size = 0;
    try {
        size = is.available();
    } catch (IOException e) {
        e.printStackTrace();
        return "";
    }
    return readFile(size, is);
}

public static String asset(Context context, String fileName) {
    InputStream is = null;
    int size = 0;
    try {
        is = context.getAssets().open(fileName);
        AssetFileDescriptor fd = null;
        fd = context.getAssets().openFd(fileName);
        size = (int) fd.getLength();
        fd.close();
    } catch (IOException e) {
        e.printStackTrace();
        return "";
    }
    return readFile(size, is);
}


private static String readFile(int size, InputStream is) {
    try {
        byte buffer[] = new byte[size];
        is.read(buffer);
        is.close();
        return new String(buffer);
    } catch (Exception e) {
        e.printStackTrace();
        return "";
    }
}

}

Par exemple :

ReadFromFile.raw(context, R.raw.textfile);

Et pour les fichiers d'actifs:

ReadFromFile.asset(context, "file.txt");
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.