Cómo Leer / Escribir una cadena desde un archivo en Android

Para aquellos que buscan una estrategia general para leer y escribir una cadena para archivar:

Primero, obtenga un objeto file

Necesitará la ruta de almacenamiento. Para el almacenamiento interno, utilizar:

File path = context.getFilesDir();

Para el almacenamiento externo (tarjeta SD), utilice:

File path = context.getExternalFilesDir(null);

Luego crea tu objeto de archivo:

File file = new File(path, "my-file-name.txt");

Escribe una cadena en el archivo

FileOutputStream stream = new FileOutputStream(file);
try {
    stream.write("text-to-write".getBytes());
} finally {
    stream.close();
}

O con Google Guayaba

String contents = Files.toString(archivo, StandardCharsets.UTF_8);

Leer el archivo en una cadena

int length = (int) file.length();

byte[] bytes = new byte[length];

FileInputStream in = new FileInputStream(file);
try {
    in.read(bytes);
} finally {
    in.close();
}

String contents = new String(bytes);   

O si está utilizando Google Guava

String contents = Files.toString(file,"UTF-8");

Para completar voy a mencionar

String contents = new Scanner(file).useDelimiter("\\A").next();

Que no requiere bibliotecas, pero los puntos de referencia 50% - 400% más lento que las otras opciones (en varias pruebas en mi Nexus 5).

Notas

Para cada una de estas estrategias, se te pedirá que cojas una excepción IOException.

La codificación de caracteres predeterminada en Android es UTF-8.

Si está utilizando almacenamiento externo, deberá agregar a su manifiesto:

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

O

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

El permiso de escritura implica permiso de lectura, por lo que no necesita ambos.

public static void writeStringAsFile(final String fileContents, String fileName) {
    Context context = App.instance.getApplicationContext();
    try {
        FileWriter out = new FileWriter(new File(context.getFilesDir(), fileName));
        out.write(fileContents);
        out.close();
    } catch (IOException e) {
        Logger.logError(TAG, e);
    }
}

public static String readFileAsString(String fileName) {
    Context context = App.instance.getApplicationContext();
    StringBuilder stringBuilder = new StringBuilder();
    String line;
    BufferedReader in = null;

    try {
        in = new BufferedReader(new FileReader(new File(context.getFilesDir(), fileName)));
        while ((line = in.readLine()) != null) stringBuilder.append(line);

    } catch (FileNotFoundException e) {
        Logger.logError(TAG, e);
    } catch (IOException e) {
        Logger.logError(TAG, e);
    } 

    return stringBuilder.toString();
}

Solo un poco de modificaciones en la lectura de la cadena de un método de archivo para un mayor rendimiento

private String readFromFile(Context context, String fileName) {
    if (context == null) {
        return null;
    }

    String ret = "";

    try {
        InputStream inputStream = context.openFileInput(fileName);

        if ( inputStream != null ) {
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);               

            int size = inputStream.available();
            char[] buffer = new char[size];

            inputStreamReader.read(buffer);

            inputStream.close();
            ret = new String(buffer);
        }
    }catch (Exception e) {
        e.printStackTrace();
    }

    return ret;
}

Compruebe el siguiente código.

Lectura de un fichero en el sistema de ficheros.

FileInputStream fis = null;
    try {

        fis = context.openFileInput(fileName);
        InputStreamReader isr = new InputStreamReader(fis);
        // READ STRING OF UNKNOWN LENGTH
        StringBuilder sb = new StringBuilder();
        char[] inputBuffer = new char[2048];
        int l;
        // FILL BUFFER WITH DATA
        while ((l = isr.read(inputBuffer)) != -1) {
            sb.append(inputBuffer, 0, l);
        }
        // CONVERT BYTES TO STRING
        String readString = sb.toString();
        fis.close();

    catch (Exception e) {

    } finally {
        if (fis != null) {
            fis = null;
        }
    }

El siguiente código es para escribir el archivo en el sistema de archivos interno.

FileOutputStream fos = null;
    try {

        fos = context.openFileOutput(fileName, Context.MODE_PRIVATE);
        fos.write(stringdatatobestoredinfile.getBytes());
        fos.flush();
        fos.close();

    } catch (Exception e) {

    } finally {
        if (fos != null) {
            fos = null;
        }
    }

Creo que esto te ayudará.

Soy un poco principiante y luché para que esto funcione hoy.

A continuación está la clase con la que terminé. Funciona, pero me preguntaba cuán imperfecta es mi solución. De todos modos, esperaba que algunos de ustedes más experimentados pudieran estar dispuestos a echar un vistazo a mi clase de IO y darme algunos consejos. ¡Salud!

public class HighScore {
    File data = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator);
    File file = new File(data, "highscore.txt");
    private int highScore = 0;

    public int readHighScore() {
        try {
            BufferedReader br = new BufferedReader(new FileReader(file));
            try {
                highScore = Integer.parseInt(br.readLine());
                br.close();
            } catch (NumberFormatException | IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            try {
                file.createNewFile();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            e.printStackTrace();
        }
        return highScore;
    }

    public void writeHighScore(int highestScore) {
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter(file));
            bw.write(String.valueOf(highestScore));
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Para añadir un archivo existente.

  File file = new File(persistPath);
  BufferedWriter out = new BufferedWriter(new FileWriter(file, true), 1024);
  out.write(str);
  out.newLine();
  out.close();