Android中的存储详解

1、存储在app内部

最简单的一种。在尝试过程中发现，手机中很多文件夹都没有权限读写。我们可以将我们需要写的文件存放到app中的files文件夹中，当然我们有权限在整个app中读写文件

可以通过api获取一个file对象，这里的this就是mainactivity类

// 获取当前包下的files路径 /data/data/top.woodwhale.qqlogin/files
file filesdir = this.getfilesdir();

之后就可以通过文件输出流写入文件：

file filesfile = new file(filesdir,"info.txt");
boolean flag = (filesfile.exists() || filesfile.createnewfile());
fileoutputstream fos = new fileoutputstream(file);
fos.write((ac+"***"+pwd).getbytes(standardcharsets.utf_8));
fos.close();

写入成功：

当然，我们既然在这个app中都有权限，那么所有目录都可以写：

// 写入到自己有权限写的地方
file file = new file("/data/data/top.woodwhale.qqlogin/info.txt");

2、sd卡外部存储

虽然现在很多的手机都不支持sd卡了，但是仍然有平板使用。

直接放出一个activity类，其中调用了nvironment.getexternalstoragedirectory();方法类获取一个sd卡file对象，使用formatter.formatfilesize(this,externalstoragedirectory.getfreespace()));formatter类中的转化，将long类型转化为大小类型，同时调用sd卡file对象的getfreespace()方法，获取卡中剩余的空间，之后就是写入externalstoragedirectory.getpath()卡中的路径

public class sdcardactivity extends activity {
    private button btn;
    public static string tag = "sdcardactivity";
    @override
    protected void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        setcontentview(r.layout.activity_sc_card_rw);
        btn = this.findviewbyid(r.id.bt_sdw);
        btn.setonclicklistener(view -> {
            file externalstoragedirectory = environment.getexternalstoragedirectory();
            log.d(tag, "sd卡路径是："+externalstoragedirectory.getpath());
            log.d(tag,"sd卡剩余空间是"+ formatter.formatfilesize(this,externalstoragedirectory.getfreespace()));
            file file = new file(externalstoragedirectory,"love.txt");
            try {
                boolean flag = file.exists() || file.createnewfile();
                if (flag) {
                    fileoutputstream fos = new fileoutputstream(file);
                    fos.write("woodwhale love sheepbotany".getbytes(standardcharsets.utf_8));
                    fos.close();
                }
            } catch (exception e) {
                e.printstacktrace();
            }
        });
    }
}

但是，在此之前，我们需要一个sd卡的读写权限，我们在androdimanifest.xml中配置下面的ses-permission

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

最终，在我们的sd卡中看到如下结果，证明写入成功：

3、sharedpreferences存储

sharedpreferences是android下的一个类，功能就是记录偏好设置，形成一个xml文件

我们可以用sharedpreferences来存储一些信息。

例如常见的这种：

我们勾选之后，再次打开app仍然处于勾选状态。

那么这种情况如何实现呢？

通过xml生成上面的布局

<?xml version="1.0" encoding="utf-8"?>
<relativelayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="80dp">

    <linearlayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:layout_centervertical="true">

        <textview
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="未知来源"
            android:textcolor="@color/teal_200"
            android:layout_marginleft="10dp"
            android:textsize="20sp" />

        <textview
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="运行安装未知来源的应用"
            android:layout_marginleft="10dp"
            android:layout_margintop="10dp"
            android:textsize="18sp"/>
    </linearlayout>

    <switch
        android:id="@+id/sw_source"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignparentright="true"
        android:layout_margintop="30dp"
        android:layout_marginright="10dp" />


</relativelayout>

我们把switch这个选择框在activity类中赋予一个变量，给他加上一个oncheckedchangelistener，再使用sharedpreferences来进行设置偏好，整体代码如下

package top.woodwhale.qqlogin;

import android.app.activity;
import android.content.sharedpreferences;
import android.os.bundle;
import android.util.log;
import android.widget.compoundbutton;
import android.widget.switch;
import androidx.annotation.nullable;

public class preferencedemoactivity  extends activity {

    private switch sw;
    public static string tag = "preferencedemoactivity";
    @override
    protected void oncreate(@nullable bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        setcontentview(r.layout.activity_pre_demo);
        sw = (switch) this.findviewbyid(r.id.sw_source);
        sharedpreferences settinginfo = this.getsharedpreferences("settinginfo", mode_private);
        sharedpreferences.editor edit = settinginfo.edit();
        sw.setoncheckedchangelistener(new mylistener(edit));
        boolean state = settinginfo.getboolean("state", true);
        log.d(tag,"state=="+ state);
        sw.setchecked(state);
    }
}

// 改变状态的监听器
class mylistener implements compoundbutton.oncheckedchangelistener {
    sharedpreferences.editor editor;
    public mylistener(sharedpreferences.editor editor) {
        this.editor = editor;
    }
    @override
    public void oncheckedchanged(compoundbutton compoundbutton, boolean b) {
        log.d(preferencedemoactivity.tag,"current state : "+ b);
        editor.putboolean("state",b);   // 要保存的数据类型
        editor.commit();        // 保存数据
    }
}

其中，editor的功能是保存数据

其次，为了每次打开app都可以看到我们的配置，通过读取偏好配置文件，设置switch框的勾选

这样就可以同步偏好设置的勾选啦！

最后我们可以在手机内部看到我们写入的偏好设置xml文件了，这样也属于存储在app内部

4、使用sqlite数据库存储

android设备自带sqlite数据库，如果掌握过mysql，那么sqlite非常容易上手，且不说提供了非常简便的api，就算是自己写也比jdbc简单！

首先我们不适用提供的api来实现一次增删改查！

4.1 自己完成一个basedao类

basedao类本来是用来连接数据库等基础的，具体的增删改查应该在service层实现，但为了这里测试，我们将crud的方法写入到basedao类中封装起来。具体架构如下：

首先是constants类，是常量类，其中有我们的数据库名、版本号、表名

public class constants {
    public static final string database_name = "woodwhale.db";
    public static final int version_code = 1;
    public static final string table_name = "user";
}

其次是databasehelper类，继承sqliteopenhelper类，用来开启数据库，其中的oncreate方法是数据库创建时的回调，onupgrade方法时升级数据时的回调，我们在constans类中写了一个版本号，爸爸那边每次升级可以加入新的功能，可以写在onupgrade方法中，通过switch实现。不过需要注意，升级只能让版本号上升，不能降级，否则会报错！

package top.woodwhale.qqlogin.sqlite.utils;

import android.content.context;
import android.database.sqlite.sqlitedatabase;
import android.database.sqlite.sqliteopenhelper;
import android.util.log;

public class databasehelper extends sqliteopenhelper {
    public static string tag = "databasehelper";
    /**
     * @param context   上下文
     */
    public databasehelper( context context) {
        super(context, constants.database_name, null, constants.version_code);
    }

    @override
    public void oncreate(sqlitedatabase sqlitedatabase) {
        // 创建时的回调
        log.d(tag, "创建数据库");
        string sql = "create table " + constants.table_name + " (id integer,name varchar,age integer)";
        sqlitedatabase.execsql(sql);
    }

    @override
    public void onupgrade(sqlitedatabase sqlitedatabase, int i, int i1) {
        // 升级数据库的回调
        log.d(tag, "升级数据库！");
        string sql = null;
        switch (i) {
            case 1:
                sql = "alter table "+ constants.table_name + " add phone integer";
                sqlitedatabase.execsql(sql);
                break;
            case 2:
                sql = "alter table "+ constants.table_name + " add address varchar";
                sqlitedatabase.execsql(sql);
                break;
        }
    }
}

最后就是我们封装好的数据库basedao类，通过语句实现了增删改查

package top.woodwhale.qqlogin.sqlite.dao;

import android.annotation.suppresslint;
import android.content.context;
import android.database.cursor;
import android.database.sqlite.sqlitedatabase;
import android.util.log;

import top.woodwhale.qqlogin.sqlite.utils.constants;
import top.woodwhale.qqlogin.sqlite.utils.databasehelper;

// basedao类
public class basedao {

    private final databasehelper dbh;
    private sqlitedatabase db;
    public static string tag = "basedao";

    public basedao(context context) {
        dbh = new databasehelper(context);
    }

    // 增
    public void add(int id, string name, int age) {
        db = dbh.getwritabledatabase();
        string sql = "insert into " + constants.table_name + "(id,name,age) values(?,?,?)";
        object[] params = new object[]{id,name,age};
        db.execsql(sql,params);
        db.close();
    }

    // 删
    public void free(int id) {
        db = dbh.getwritabledatabase();
        string sql = "delete from " + constants.table_name + " where id=?";
        object[] params = new object[]{id};
        db.execsql(sql,params);
        db.close();
    }

    // 改
    public void edit(int id, int age) {
        db = dbh.getwritabledatabase();
        string sql = "update " + constants.table_name +" set age = ? where id = ?";
        object[] params = new object[]{age,id};
        db.execsql(sql,params);
        db.close();
    }

    // 查
    @suppresslint("range")
    public void show(int id) {
        db = dbh.getreadabledatabase();
        string sql = "select * from  " + constants.table_name +" where id = ?";
        string[] params = new string[]{string.valueof(id)};
        cursor cursor =  db.rawquery(sql, params);
        while (cursor.movetonext()) {
            string name = cursor.getstring(cursor.getcolumnindex("name"));
            log.d(tag,"name == "+name);
            int age = cursor.getint(cursor.getcolumnindex("age"));
            log.d(tag,"age == "+age);
        }
        cursor.close();
        db.close();
    }
}

接着我们在androidtest包下进行测试

package top.woodwhale.qqlogin;

import android.content.context;
import android.database.sqlite.sqlitedatabase;
import android.util.log;

import androidx.test.platform.app.instrumentationregistry;
import androidx.test.ext.junit.runners.androidjunit4;

import org.junit.test;
import org.junit.runner.runwith;

import static org.junit.assert.*;

import top.woodwhale.qqlogin.sqlite.dao.basedao;
import top.woodwhale.qqlogin.sqlite.utils.databasehelper;

/**
 * instrumented test, which will execute on an android device.
 *
 * @see <a href="http://d.android.com/tools/testing" rel="external nofollow" >testing documentation</a>
 */
@runwith(androidjunit4.class)
public class exampleinstrumentedtest {

    public static final string tag = "exampleinstrumentedtest";
    public static final context appcontext = instrumentationregistry.getinstrumentation().gettargetcontext();;
    public static final basedao dao = new basedao(appcontext);;

    @test
    public void useappcontext() {
        // context of the app under test.
        assertequals("top.woodwhale.qqlogin", appcontext.getpackagename());
    }

    @test
    public void testcreate() {
        databasehelper dbh = new databasehelper(appcontext);
        sqlitedatabase writabledatabase = dbh.getwritabledatabase();
        log.d(tag, writabledatabase.getpath());
    }

    @test
    public void testadd() {
        dao.add(1,"woodwhale",19);
        dao.add(2,"sheepbotany",21);
    }
    @test
    public void testfree() {
        dao.free(1);
    }
    @test
    public void testedit() {
        dao.edit(1,3);
    }
    @test
    public void testshow() {
        dao.show(1);
    }

}

增删改查都成功，成功就如图所示：

由于只有查询有log回显，在logcat中之后show方法出现了log

4.2 使用google写的api处理

那么使用google写好的增删改查api可以避免我们sql语句的格式问题和语法错误

经过测试，如下代码没有问题（在basedao类中）

// 使用api的添加
    public void addbyapi(int id, string name, int age) {
        contentvalues contentvalues = new contentvalues();
        contentvalues.put("id",id);
        contentvalues.put("name",name);
        contentvalues.put("age",age);
        db = dbh.getwritabledatabase();
        db.insert(constants.table_name,null,contentvalues);
        db.close();
    }
    // 删除
    public void freebyapi(int id) {
        db = dbh.getwritabledatabase();
        db.delete(constants.table_name,"id = ?",new string[]{string.valueof(id)});
        db.close();
        log.d(tag,"api删除成功！");
    }
    // 修改
    public void editbyapi(int id, string name, integer age) {
        contentvalues contentvalues = new contentvalues();
        if (name != null) {
            contentvalues.put("name",name);
        }
        if (age != null) {
            contentvalues.put("age",age);
        }
        db = dbh.getwritabledatabase();
        db.update(constants.table_name,contentvalues,"id = ?", new string[]{string.valueof(id)});
        db.close();
    }
    // 查询
    public void showbyapi(int id) {
        db = dbh.getreadabledatabase();
        cursor cursor = db.query(false, constants.table_name, new string[]{"id", "name", "age"}, "id = ?", new string[]{string.valueof(id)}, "id", null, null, null);
        while (cursor.movetonext()) {
            int id = cursor.getint(0);
            log.d(tag,"id == "+id);
            string name = cursor.getstring(1);
            log.d(tag,"name == "+name);
            int age = cursor.getint(2);
            log.d(tag,"age == "+age);
        }
        cursor.close();
        db.close();

    }

4.3 事务使用

使用db.begintransaction(); db.settransactionsuccessful(); db.endtransaction();三个方法来进行事务的处理。

简单的一个测试类

// 测试一个数据库事物
    @test
    public void testtransaction() {
        databasehelper dbh = new databasehelper(appcontext);
        sqlitedatabase db = dbh.getwritabledatabase();
        db.begintransaction();
        log.d(tag,"事物开启！");
        try {
            db.execsql("update " + constants.table_name +" set age = 114 where id = 1");
            int i = 10 / 0;
            db.execsql("update " + constants.table_name +" set age = 114 where id = 2");
            db.settransactionsuccessful();
            log.d(tag,"事物成功！");
        } catch (exception e) {
            e.printstacktrace();
        } finally {
            db.endtransaction();
            db.close();
            log.d(tag,"事物关闭！");
        }
        dao.showbyapi(1);
        dao.showbyapi(2);
    }

看看logcat，首先是进入了 事物开启，然后程序进入了try中，因为除以了一个0所以报错，捕获异常了之后就是进入到finally中关闭了事务，可以发现我们sql中的信息都回滚了，没有改变。

我们把int i = 10 / 0;删了试一试，可以看到成功执行事物。

值得注意的是，事物开启之后，仅有当前的db对象可以执行sql语句，使用dao类中的方法是无法进行增删改查的，因为对这些得到的db对象上了锁！

总结

到此这篇关于android中的存储详解的文章就介绍到这了,更多相关android存储内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！