Como salvar dados no Android

Editado 4 meses atrás por ExtremeHow Equipe Editorial

AndroidEconomia de DadosConectividadeOtimizaçãoConfiguraçõesSmartphonesDicasDispositivos MóveisGestão de DadosInterface do Usuário

Salvar dados em um dispositivo Android é uma parte essencial do desenvolvimento de aplicativos móveis. Este documento irá fornecer-lhe uma compreensão abrangente dos vários métodos utilizados para salvar dados em um dispositivo Android. Existem muitas maneiras de salvar dados, incluindo preferências compartilhadas, armazenamento interno, armazenamento externo, bancos de dados SQLite e mais.

Entendendo as opções de armazenamento de dados

Antes de entrar nos detalhes de cada método de armazenamento, é importante entender os princípios gerais que orientam o armazenamento de dados no Android. Você precisa considerar fatores como o tipo de dado que está salvando, a consistência necessária desses dados e a privacidade dos dados. Vamos primeiro delinear as principais opções de armazenamento de dados que você tem no Android:

• Shared Preferences: Ideal para armazenar pares simples de chave-valor de tipos de dados primitivos.
• Armazenamento interno: Usado para salvar arquivos diretamente na memória interna do dispositivo.
• Armazenamento externo: Permite que arquivos sejam salvos em um meio de armazenamento removível.
• Banco de Dados SQLite: Mais adequado para armazenar dados estruturados em formato de banco de dados.
• Biblioteca de Persistência Room: Uma abstração de alto nível sobre o SQLite que simplifica o acesso ao banco de dados.

Usando preferências compartilhadas

Shared Preferences é adequado para armazenar pequenas quantidades de dados na forma de pares chave-valor. É frequentemente usado para salvar configurações de usuário ou preferências de aplicativos. Veja como você pode usar SharedPreferences em seu aplicativo Android:

Passo 1: Obter uma instância

Você pode obter uma instância de SharedPreferences chamando o método getSharedPreferences(), que requer dois parâmetros: o nome do arquivo de preferências e o modo.

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

Passo 2: Salvar os dados

Para salvar dados em SharedPreferences, você precisa usar o objeto SharedPreferences.Editor. Veja uma maneira rápida de fazer isso:

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

Passo 3: Recuperar dados

Obter dados de preferências compartilhadas é simples. Você pode usar métodos getX(), onde X é o tipo de dado que deseja obter:

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

Usando armazenamento interno

O armazenamento interno é usado para salvar arquivos que apenas seu aplicativo pode acessar. Ele é mais adequado para dados privados. Veja como você pode trabalhar com o armazenamento interno:

Passo 1: Escrever no arquivo

Você pode escrever em um arquivo usando a classe FileOutputStream. Aqui está um exemplo de como escrever um arquivo de texto simples:

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

Passo 2: Ler do arquivo

Para ler um arquivo do armazenamento interno, você precisa 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 armazenamento externo

O armazenamento externo pode ser uma mídia removível, como um cartão SD, ou uma parte da memória do dispositivo que é acessível ao usuário. Isso é útil para arquivos grandes ou arquivos que podem ser compartilhados entre aplicativos. Veja como você pode usar o armazenamento externo:

Permissões

Antes de usar o armazenamento externo, certifique-se de que seu arquivo AndroidManifest.xml inclua as permissões necessárias:

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

Escrever no armazenamento externo

Para escrever dados no armazenamento externo, use a classe File para definir um diretório e caminho de arquivo:

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

Ler do armazenamento externo

Ler um arquivo do armazenamento externo pode ser feito usando 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 um Banco de Dados SQLite

O SQLite é uma opção de armazenamento poderosa para dados estruturados e fornece um banco de dados SQL completo para armazenar dados. É perfeito para estruturas de dados grandes ou complexas. Vamos aprender como criar e usar um banco de dados SQLite no Android:

Passo 1: Criar uma Classe Helper de Banco de Dados

Você precisa criar uma classe helper que estende SQLiteOpenHelper para gerenciar a criação e o gerenciamento de versão do banco de dados:

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); } }

Passo 2: Inserir os dados

Você pode fazer a entrada de dados 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);

Passo 3: Consultar os dados

A consulta de dados é feita usando o método query() ou 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 a Biblioteca de Persistência Room

O Room é uma camada de abstração sobre o SQLite que simplifica o acesso ao banco de dados, permitindo que você escreva suas consultas na API Fluent ou confie nos diagnósticos SQL de tempo de compilação. Aqui estão os passos básicos:

Passo 1: Definir a entidade

Defina uma entidade para a representação da tabela usando a anotação @Entity:

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

Passo 2: Definir o Objeto de Acesso a Dados (DAO)

Você define métodos para acessar o banco de dados através do DAO:

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

Passo 3: Criar o Banco de Dados

Crie uma classe abstrata que estende RoomDatabase e contém as entidades e DAOs:

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

Passo 4: Usar o banco de dados

Você pode usar o banco de dados definido em seu aplicativo da seguinte forma:

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

Em conclusão, o Android oferece vários métodos para armazenamento de dados, e você pode escolher entre eles com base em suas necessidades específicas. Compreender as forças e limitações de cada método irá guiá-lo na tomada de decisões práticas durante o desenvolvimento do seu aplicativo.

  Compartilhe Este Artigo

Se você encontrar algo errado com o conteúdo do artigo, você pode solicitar uma atualização