Cómo guardar datos en Android

Editado 4 hace meses por ExtremeHow Equipo Editorial

AndroidAhorro de datosConectividadOptimizaciónConfiguraciónTeléfonos inteligentesConsejosDispositivos MóvilesGestión de datosInterfaz de usuario

Guardar datos en un dispositivo Android es una parte esencial del desarrollo de aplicaciones móviles. Este documento le proporcionará una comprensión integral de los diversos métodos utilizados para guardar datos en un dispositivo Android. Hay muchas formas de guardar datos, incluidas las preferencias compartidas, el almacenamiento interno, el almacenamiento externo, las bases de datos SQLite y más.

Comprender las opciones de almacenamiento de datos

Antes de entrar en los detalles de cada método de almacenamiento, es importante entender los principios generales que guían el almacenamiento de datos en Android. Debe considerar factores como el tipo de datos que está guardando, la consistencia requerida de estos datos y la privacidad de los datos. Primero enumeremos las principales opciones de almacenamiento de datos que tiene en Android:

• Preferencias compartidas: Ideal para almacenar pares clave-valor simples de tipos de datos primitivos.
• Almacenamiento interno: Se utiliza para guardar archivos directamente en la memoria interna del dispositivo.
• Almacenamiento externo: Permite que los archivos se guarden en un medio de almacenamiento extraíble.
• Base de datos SQLite: Más adecuado para almacenar datos estructurados en formato de base de datos.
• Biblioteca de persistencia Room: Una abstracción de alto nivel sobre SQLite que simplifica el acceso a la base de datos.

Usando preferencias compartidas

Las preferencias compartidas son adecuadas para almacenar pequeñas cantidades de datos en forma de pares clave-valor. A menudo se utilizan para guardar configuraciones de usuario o preferencias de la aplicación. Así es cómo puede usar SharedPreferences en su aplicación de Android:

Paso 1: Obtener una instancia

Puede obtener una instancia de SharedPreferences llamando al método getSharedPreferences(), que requiere dos parámetros: el nombre del archivo de preferencias y el modo.

SharedPreferences sharedPreferences = getSharedPreferences("MyPrefs", MODE_PRIVATE);

Paso 2: Guardar los datos

Para guardar datos en SharedPreferences, debe usar el objeto SharedPreferences.Editor. Aquí hay una forma rápida de hacerlo:

SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putString("username", "john_doe"); editor.putInt("user_id", 12345); editor.apply();

Paso 3: Recuperar datos

Obtener datos de preferencias compartidas es simple. Puede usar los métodos getX(), donde X es el tipo de datos que desea obtener:

String username = sharedPreferences.getString("username", "default_name"); int userId = sharedPreferences.getInt("user_id", 0);

Usando almacenamiento interno

El almacenamiento interno se utiliza para guardar archivos a los que solo su aplicación puede acceder. Es más adecuado para datos privados. Así es cómo puede trabajar con el almacenamiento interno:

Paso 1: Escribir en el archivo

Puede escribir en un archivo usando la clase FileOutputStream. Aquí hay un ejemplo de escritura de un archivo de texto simple:

String filename = "myfile.txt"; String fileContents = "¡Hola Mundo!"; FileOutputStream fos = openFileOutput(filename, Context.MODE_PRIVATE); fos.write(fileContents.getBytes()); fos.close();

Paso 2: Leer del archivo

Para leer un archivo del almacenamiento interno, necesita usar FileInputStream:

FileInputStream fis = openFileInput(filename); InputStreamReader inputStreamReader = new InputStreamReader(fis); BufferedReader bufferedReader = new BufferedReader(inputStreamReader); StringBuilder sb = new StringBuilder(); String line; while ((line = bufferedReader.readLine()) != null) { sb.append(line); } String fileContents = sb.toString();

Usando almacenamiento externo

El almacenamiento externo puede ser un medio removible como una tarjeta SD o una parte de la memoria del dispositivo que es accesible para el usuario. Esto es útil para archivos grandes o archivos que se pueden compartir entre aplicaciones. Así es cómo puede usar el almacenamiento externo:

Permisos

Antes de usar el almacenamiento externo, asegúrese de que su archivo AndroidManifest.xml incluya los permisos requeridos:

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

Escribir en almacenamiento externo

Para escribir datos en almacenamiento externo, use la clase File para definir un directorio y una ruta de archivo:

File externalStorageDir = Environment.getExternalStorageDirectory(); File myFile = new File(externalStorageDir, "myfile.txt"); FileOutputStream fos = new FileOutputStream(myFile); fos.write("¡Hola Mundo!".getBytes()); fos.close();

Leer de almacenamiento externo

Leer un archivo del almacenamiento externo se puede lograr utilizando FileInputStream:

FileInputStream fis = new FileInputStream(myFile); InputStreamReader inputStreamReader = new InputStreamReader(fis); BufferedReader bufferedReader = new BufferedReader(inputStreamReader); StringBuilder sb = new StringBuilder(); String line; while ((line = bufferedReader.readLine()) != null) { sb.append(line); } String fileContents = sb.toString();

Usando una base de datos SQLite

SQLite es una opción de almacenamiento potente para datos estructurados y proporciona una base de datos SQL completa para almacenar datos. Es perfecto para estructuras de datos grandes o complejas. Aprendamos cómo crear y usar una base de datos SQLite en Android:

Paso 1: Crear una clase de Helper para la base de datos

Debe crear una clase de ayuda que extienda SQLiteOpenHelper para gestionar la creación y gestión de la versión de la base de datos:

public class MyDbHelper extends SQLiteOpenHelper { private static final int DATABASE_VERSION = 1; private static final String DATABASE_NAME = "mydatabase.db"; public MyDbHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); } @Override public void onCreate(SQLiteDatabase db) { db.execSQL("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)"); } @Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { db.execSQL("DROP TABLE IF EXISTS users"); onCreate(db); } }

Paso 2: Introducir los datos

Puede ingresar datos usando ContentValues:

MyDbHelper dbHelper = new MyDbHelper(getContext()); SQLiteDatabase db = dbHelper.getWritableDatabase(); ContentValues values = new ContentValues(); values.put("name", "John Doe"); values.put("age", 29); long newRowId = db.insert("users", null, values);

Paso 3: Consultar los datos

La consulta de datos se realiza utilizando el método query() o rawQuery():

SQLiteDatabase db = dbHelper.getReadableDatabase(); Cursor cursor = db.query("users", new String[] {"id", "name", "age"}, null, null, null, null, null ); while(cursor.moveToNext()) { long userId = cursor.getLong(cursor.getColumnIndexOrThrow("id")); String userName = cursor.getString(cursor.getColumnIndexOrThrow("name")); int userAge = cursor.getInt(cursor.getColumnIndexOrThrow("age")); } cursor.close();

Usando la biblioteca de persistencia Room

Room es una capa de abstracción sobre SQLite que simplifica el acceso a la base de datos, lo que le permite escribir sus consultas en la API Fluent o confiar en los diagnósticos de SQL en tiempo de compilación. Aquí están los pasos básicos:

Paso 1: Definir la entidad

Defina una entidad para la representación de la tabla usando la anotación @Entity:

@Entity public class User { @PrimaryKey public int id; public String name; public int age; }

Paso 2: Definir el Objeto de Acceso a Datos (DAO)

Define métodos para acceder a la base de datos a través del DAO:

@Dao public interface UserDao { @Insert void insertAll(User... users); @Query("SELECT * FROM user") List<User> getAll(); }

Paso 3: Crear la Base de Datos

Cree una clase abstracta que extienda RoomDatabase y que contenga las entidades y los DAOs:

@Database(entities = {User.class}, version = 1) public abstract class AppDatabase extends RoomDatabase { public abstract UserDao userDao(); }

Paso 4: Usar la base de datos

Puede usar la base de datos definida en su aplicación de la siguiente manera:

AppDatabase db = Room.databaseBuilder(getApplicationContext(), AppDatabase.class, "database-name").build(); UserDao userDao = db.userDao(); List<User> users = userDao.getAll();

En conclusión, Android ofrece varios métodos para el almacenamiento de datos, y puede elegir entre ellos según sus necesidades específicas. Comprender las fortalezas y limitaciones de cada método le guiará a tomar decisiones prácticas durante el desarrollo de su aplicación.

  Comparte este artículo

Si encuentras algo incorrecto en el contenido del artículo, puedes solicitar una actualización