一、什么是数据持久化

在Android中，数据持久化是将数据保存在应用程序中，使得在程序关闭后，数据也不会丢失，并能够在下一次启动应用程序时读取这些数据。

数据持久化的方式有很多种，比如说SharedPreferences、SQLite数据库、文件存储、Content Provider等。

其中，SharedPreferences是一种轻量级的数据存储方式，适合存储少量的数据，SQLite数据库适合存储大量的结构化数据，文件存储则适合存储一些大型文件，而Content Provider适合在多个应用程序之间共享数据。

二、SharedPreferences

SharedPreferences是Android中一种轻量级的存储方式，适用于存储一些简单的键值对。SharedPreferences提供了读取和写入数据的方法，可以在应用程序的任意位置进行操作，无需通过Content Provider或文件操作进行读写。

SharedPreferences的使用非常简单，只需要使用getSharedPreferences()方法获取SharedPreferences对象，然后就可以使用putXXX()和getXXX()方法进行存储和读取数据了。

// 存储数据
SharedPreferences sharedPreferences = getSharedPreferences("MyData", MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("username", "Tom");
editor.putBoolean("is_login", true);
editor.commit();

// 读取数据
String username = sharedPreferences.getString("username", "");
boolean isLogin = sharedPreferences.getBoolean("is_login", false);

三、SQLite数据库

在Android中，SQLite数据库是一种基于文件的轻量级数据库，适合存储大量的结构化数据。SQLite数据库使用SQL语言进行操作，可以进行搜索、排序、过滤等操作。

首先，需要定义数据库的表和表的字段，然后使用SQLiteOpenHelper类对数据库进行管理。其中，onCreate()方法用于创建数据库和表，onUpgrade()方法用于升级数据库。

使用SQLiteOpenHelper类可以进行数据库的创建、更新和删除，同时可以使用SQLiteDatabase类进行数据的读写操作。

// 创建数据库
public class MyDatabaseHelper extends SQLiteOpenHelper {
    private static final String DATABASE_NAME = "MyDB";
    private static final int DATABASE_VERSION = 1;

    public MyDatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE user (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 user");
        onCreate(db);
    }
}

// 使用数据库
MyDatabaseHelper helper = new MyDatabaseHelper(context);
SQLiteDatabase db = helper.getWritableDatabase();

// 插入数据
ContentValues values = new ContentValues();
values.put("name", "Tom");
values.put("age", 20);
db.insert("user", null, values);

// 更新数据
ContentValues values = new ContentValues();
values.put("age", 21);
db.update("user", values, "name=?", new String[]{"Tom"});

// 删除数据
db.delete("user", "id=?", new String[]{"1"});

// 查询数据
Cursor cursor = db.query("user", new String[]{"id","name","age"}, null, null, null, null, "age DESC");
if (cursor.moveToFirst()) {
    do {
        int id = cursor.getInt(cursor.getColumnIndex("id"));
        String name = cursor.getString(cursor.getColumnIndex("name"));
        int age = cursor.getInt(cursor.getColumnIndex("age"));
    } while (cursor.moveToNext());
}
cursor.close();
db.close();

四、文件存储

文件存储是一种与具体数据和数据结构无关的存储方式，可以用于存储一些文件或者文本信息。在Android中，文件存储可以使用FileOutputStream和FileInputStream实现。

通过FileOutputStream可以将数据写入文件，通过FileInputStream可以从文件中读取数据。在进行文件存储时，需要注意文件存储的路径，应该将数据存储在Android指定的目录下。

// 文件存储
String fileName = "data.txt";
String fileContent = "This is a file.";
FileOutputStream outputStream = null;
try {
    outputStream = openFileOutput(fileName, MODE_PRIVATE);
    outputStream.write(fileContent.getBytes());
    outputStream.flush();
    Log.i(TAG, "文件存储成功！");
} catch (Exception e) {
    Log.e(TAG, "文件存储失败：" + e.getMessage());
} finally {
    try {
        outputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// 文件读取
try {
    FileInputStream inputStream = openFileInput(fileName);
    byte[] bytes = new byte[inputStream.available()];
    inputStream.read(bytes);
    String fileContent = new String(bytes);
    Log.i(TAG, "文件读取成功，内容为：" + fileContent);
} catch (Exception e) {
    Log.e(TAG, "文件读取失败：" + e.getMessage());
}

五、Content Provider

Content Provider是一种跨进程的数据管理方式，可以将数据暴露给其他应用程序使用。Content Provider可以在AndroidManifest.xml中进行注册，在应用程序中通过URI访问数据。

使用Content Provider时，需要定义数据的URI以及相应的数据类型和操作方式。Content Provider还需要继承ContentProvider基类，实现查询、插入、更新和删除等方法。

// 定义URI
public static final String AUTHORITY = "com.example.provider";
public static final Uri USER_URI = Uri.parse("content://" + AUTHORITY + "/user");

// 映射数据类型
public static final int USERS = 1;
public static final String USER_TYPE = "vnd.android.cursor.dir/vnd.com.example.provider.user";

// 创建ContentProvider
public class MyContentProvider extends ContentProvider {
    private MyDatabaseHelper dbHelper;
    private static final UriMatcher URI_MATCHER = new UriMatcher(UriMatcher.NO_MATCH);

    static {
        URI_MATCHER.addURI(AUTHORITY, "user", USERS);
    }

    @Override
    public boolean onCreate() {
        dbHelper = new MyDatabaseHelper(getContext());
        return true;
    }

    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        SQLiteDatabase db = dbHelper.getReadableDatabase();
        Cursor cursor = null;
        switch (URI_MATCHER.match(uri)) {
            case USERS:
                cursor = db.query("user",projection,selection,selectionArgs,null,null,sortOrder);
                break;
        }
        return cursor;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        switch (URI_MATCHER.match(uri)) {
            case USERS:
                return USER_TYPE;
        }
        return null;
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        Uri result = null;
        switch (URI_MATCHER.match(uri)) {
            case USERS:
                long id = db.insert("user",null,values);
                result = ContentUris.withAppendedId(uri, id);
                break;
        }
        return result;
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        int rows = 0;
        switch (URI_MATCHER.match(uri)) {
            case USERS:
                rows = db.update("user",values,selection,selectionArgs);
                break;
        }
        return rows;
    }

    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
        SQLiteDatabase db = dbHelper.getWritableDatabase();
        int rows = 0;
        switch (URI_MATCHER.match(uri)) {
            case USERS:
                rows = db.delete("user",selection,selectionArgs);
                break;
        }
        return rows;
    }
}

// 使用Content Provider
ContentResolver resolver = context.getContentResolver();

// 查询数据
String[] projection = {"id","name","age"};
Cursor cursor = resolver.query(MyContentProvider.USER_URI,projection,null,null,"age DESC");
if (cursor.moveToFirst()) {
    do {
        int id = cursor.getInt(cursor.getColumnIndex("id"));
        String name = cursor.getString(cursor.getColumnIndex("name"));
        int age = cursor.getInt(cursor.getColumnIndex("age"));
    } while (cursor.moveToNext());
}
cursor.close();

// 插入数据
ContentValues values = new ContentValues();
values.put("name", "Tom");
values.put("age", 20);
Uri resultUri = resolver.insert(MyContentProvider.USER_URI, values);

// 更新数据
values.clear();
values.put("age", 21);
int rows = resolver.update(MyContentProvider.USER_URI, values, "name=?", new String[]{"Tom"});

// 删除数据
rows = resolver.delete(MyContentProvider.USER_URI, "id=?", new String[]{"1"});