Lecture d'un simple fichier texte
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);
mes questions sont :
Où dois-je placer ce fichier "test.txt"
dans mon projet?. J'ai essayé de mettre le fichier sous "res/raw"
et "asset"
, mais j'obtiens le dossier exception "FileNotFound"
quand le premier live du code écrit ci-dessus est exécuté.
Merci pour l'aide
7 réponses
Placez votre fichier texte dans le répertoire /assets
sous le projet Android. Utilisez la classe AssetManager
pour y accéder.
AssetManager am = context.getAssets();
InputStream is = am.open("test.txt");
ou vous pouvez également mettre le fichier dans le répertoire /res/raw
, où le fichier sera indexé et est accessible par un id dans le fichier R:
InputStream is = context.getResources().openRawResource(R.raw.test);
essayez cette,
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();
}
}
C'est comment je le 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")
avoir un fichier dans votre dossier assets
vous oblige à utiliser ce morceau de code afin d'obtenir des fichiers à partir du dossier assets
:
yourContext.getAssets().open("test.txt");
dans cet exemple, getAssets()
renvoie une instance AssetManager
et vous êtes libre d'utiliser la méthode que vous voulez à partir de L'API AssetManager
.
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); }
pour lire le fichier sauvegardé dans le dossier actif
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 "" ;
}
}
Voici une classe simple qui gère à la fois raw
et asset
fichiers:
public class 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");