Android 之 存储（Assets目录，SharedPreferences,数据库，内部存储等）

原创 已于 2025-08-09 12:35:52 修改 · 294 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android

于 2025-08-03 10:52:28 首次发布

一.Assets目录操作

/**
 * 读取Assets目录下面的json文件
 * 
 */
public class JAssetsUtils {
    
    /**
     * 读取Assets目录下面指定文件并返回String数据
     * @param context
     * @param fileName
     * @return
     */
    public static String getJsonDataFromAssets(Context context, String fileName) {
        StringBuilder stringBuilder = new StringBuilder();
        InputStream inputStream = context.getClass().getClassLoader().getResourceAsStream("assets/" + fileName);
        try {
            byte[] buffer = new byte[inputStream.available()];
            inputStream.read(buffer);
            String json = new String(buffer, "utf-8");
            stringBuilder = stringBuilder.append(json);
        }
        catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                inputStream.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
        return stringBuilder.toString();
    }
}

二.SharedPreferences

1.封装工具类

public class SpfUtils {
    /**
     * 保存在手机里面的文件名
     */
    public static final String FILE_NAME = "share_data";
 
    /**
     * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法
     *
     * @param context
     * @param key
     * @param object
     */
    public static void put(Context context, String key, Object object) {
 
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();
 
        if (object instanceof String) {
            editor.putString(key, (String) object);
        } else if (object instanceof Integer) {
            editor.putInt(key, (Integer) object);
        } else if (object instanceof Boolean) {
            editor.putBoolean(key, (Boolean) object);
        } else if (object instanceof Float) {
            editor.putFloat(key, (Float) object);
        } else if (object instanceof Long) {
            editor.putLong(key, (Long) object);
        } else {
            editor.putString(key, object.toString());
        }
 
        SharedPreferencesCompat.apply(editor);
    }
 
    /**
     * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值
     *
     * @param context
     * @param key
     * @param defaultObject
     * @return
     */
    public static Object get(Context context, String key, Object defaultObject) {
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                Context.MODE_PRIVATE);
 
        if (defaultObject instanceof String) {
            return sp.getString(key, (String) defaultObject);
        } else if (defaultObject instanceof Integer) {
            return sp.getInt(key, (Integer) defaultObject);
        } else if (defaultObject instanceof Boolean) {
            return sp.getBoolean(key, (Boolean) defaultObject);
        } else if (defaultObject instanceof Float) {
            return sp.getFloat(key, (Float) defaultObject);
        } else if (defaultObject instanceof Long) {
            return sp.getLong(key, (Long) defaultObject);
        }
 
        return null;
    }
 
    /**
     * 移除某个key值已经对应的值
     *
     * @param context
     * @param key
     */
    public static void remove(Context context, String key) {
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();
        editor.remove(key);
        SharedPreferencesCompat.apply(editor);
    }
 
    /**
     * 清除所有数据
     *
     * @param context
     */
    public static void clear(Context context) {
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = sp.edit();
        editor.clear();
        SharedPreferencesCompat.apply(editor);
    }
 
    /**
     * 查询某个key是否已经存在
     *
     * @param context
     * @param key
     * @return
     */
    public static boolean contains(Context context, String key) {
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                Context.MODE_PRIVATE);
        return sp.contains(key);
    }
 
    /**
     * 返回所有的键值对
     *
     * @param context
     * @return
     */
    public static Map<String, ?> getAll(Context context) {
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,
                Context.MODE_PRIVATE);
        return sp.getAll();
    }
 
    /**
     * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
     *
     * @author zhy
     */
    private static class SharedPreferencesCompat {
        private static final Method sApplyMethod = findApplyMethod();
 
        /**
         * 反射查找apply的方法
         *
         * @return
         */
        @SuppressWarnings({"unchecked", "rawtypes"})
        private static Method findApplyMethod() {
            try {
                Class<SharedPreferences.Editor> clz = SharedPreferences.Editor.class;
                return clz.getMethod("apply");
            } catch (NoSuchMethodException e) {
            }
 
            return null;
        }
 
        /**
         * 如果找到则使用apply执行，否则使用commit
         *
         * @param editor
         */
        public static void apply(SharedPreferences.Editor editor) {
            try {
                if (sApplyMethod != null) {
                    sApplyMethod.invoke(editor);
                    return;
                }
            } catch (IllegalArgumentException e) {
            } catch (IllegalAccessException e) {
            } catch (InvocationTargetException e) {
            }
            editor.commit();
        }
    }
 
}

2.存储数据

SpfUtils.put(OBU_Trade_Activity.this,"ber_xiaofei",text);

3.读取数据

boolean lanyas = (boolean) SpfUtils.get(this, "lanya", true);

三.sqllite数据库使用-第三方数据库ormlite

 ​​一、基础配置​​

​​1. 添加依赖​​

在 build.gradle 中引入 OrmLite：

dependencies {
    implementation 'com.j256.ormlite:ormlite-android:5.0'
    implementation 'com.j256.ormlite:ormlite-core:5.0'
}

2. 权限声明（如需操作外部存储）​

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

​​二、数据模型定义​​

使用注解将 Java 类映射为数据库表：

@DatabaseTable(tableName = "users")
public class User {
    @DatabaseField(generatedId = true) // 自增主键
    private int id;
    
    @DatabaseField(columnName = "name", canBeNull = false)
    private String name;
    
    @DatabaseField(columnName = "age")
    private int age;

    // 必须包含无参构造方法
    public User() {} 
    // Getter/Setter 省略
}

注解说明​​：

@DatabaseTable：指定表名。
@DatabaseField：定义字段属性，支持 generatedId（自增）、unique（唯一）、foreign（外键）等。
​​强制要求​​：类必须提供无参构造方法

三、数据库管理​​

​​1. 创建 DatabaseHelper​​

继承 OrmLiteSqliteOpenHelper 管理数据库：

public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
    private static final String DB_NAME = "app.db";
    private static final int DB_VERSION = 1;

    public DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db, ConnectionSource cs) {
        try {
            TableUtils.createTable(cs, User.class); // 创建表
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, ConnectionSource cs, int oldVer, int newVer) {
        try {
            TableUtils.dropTable(cs, User.class, true); // 删除旧表
            onCreate(db, cs); // 重建新表
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 单例模式获取 Helper
    public static synchronized DatabaseHelper getInstance(Context context) {
        if (instance == null) {
            instance = new DatabaseHelper(context);
        }
        return instance;
    }
}

四、CRUD 操作​

1. 获取 Dao 对象​​
DatabaseHelper helper = DatabaseHelper.getInstance(context);
Dao<User, Integer> userDao = helper.getDao(User.class); // 泛型：模型类 + 主键类型

​​2. 插入数据​​
User user = new User("Alice", 30);
userDao.create(user); // 插入单条
// 或防重复插入：userDao.createIfNotExists(user);


​​3. 查询数据​​
// 查询所有用户
List<User> users = userDao.queryForAll();


// 按条件查询（年龄大于25）
List<User> users = userDao.queryBuilder()
                    .where().gt("age", 25)
                    .query();


​​4. 更新数据​​
user.setName("Bob");
userDao.update(user); // 更新整个对象
// 或部分更新：UpdateBuilder


​​5. 删除数据​​
userDao.deleteById(1); // 按ID删除
// 或条件删除：userDao.deleteBuilder().where().eq("name", "Alice").delete();


6.高级，条件查询
QueryBuilder<VideoTagInfo, Integer> queryBuilder = videoTagInfoIntegerDao.queryBuilder();
try {
    queryBuilder.where().eq("value",roomId).and().eq("myFocus",true);
    VideoTagInfo videoTagInfo = queryBuilder.queryForFirst();
    long count = queryBuilder.countOf();
    Log.i("ss","___count:"+count+"_____videoTagInfo:"+videoTagInfo);
    if(videoTagInfo != null){
        return true;
    }
 
} catch (SQLException e) {
    Log.i("ss","__e:"+e);
    e.printStackTrace();
 
}

7.高级， 更新

UpdateBuilder<Life_Devices, Integer> life_devicesIntegerUpdateBuilder = userDao.updateBuilder();
life_devicesIntegerUpdateBuilder.updateColumnValue("storid", storid).where().eq("deviceid", deviceid);
life_devicesIntegerUpdateBuilder.update();

四.内部存储

以下是一个功能全面的Android文件操作工具类FileUtils，集成了内部存储、外部存储、文件加密等常用操作，并适配了Android 10+的分区存储限制。代码包含详细注释和异常处理，可直接集成到项目中：

import android.content.Context;
import android.os.Environment;
import android.util.Log;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

/**
 * 文件操作工具类（兼容Android 10+）
 * 功能：文件读写、加密存储、目录管理、缓存清理等
 */
public final class FileUtils {
    private static final String TAG = "FileUtils";
    private static final String AES_KEY = "YourAESKey123456"; //  AES密钥（需自定义）

    // 禁用构造方法
    private FileUtils() {
        throw new UnsupportedOperationException("工具类无需实例化");
    }

    /*------------------------ 内部存储操作 ------------------------*/
    
    /**
     * 保存文本到内部私有目录
     * @param context 上下文
     * @param fileName 文件名（不含路径）
     * @param content 文本内容
     * @param mode 写入模式（Context.MODE_PRIVATE 或 MODE_APPEND）
     */
    public static void writeInternal(Context context, String fileName, String content, int mode) {
        try (FileOutputStream fos = context.openFileOutput(fileName, mode)) {
            fos.write(content.getBytes(StandardCharsets.UTF_8));
        } catch (IOException e) {
            Log.e(TAG, "内部存储写入失败: " + e.getMessage());
        }
    }

    /**
     * 读取内部存储文件
     * @return 文件内容，失败返回空字符串
     */
    public static String readInternal(Context context, String fileName) {
        try (FileInputStream fis = context.openFileInput(fileName);
             BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            return sb.toString();
        } catch (IOException e) {
            Log.e(TAG, "内部存储读取失败: " + e.getMessage());
            return "";
        }
    }

    /*------------------------ 外部存储操作（适配分区存储） ------------------------*/
    
    /**
     * 获取应用专属外部存储目录
     * @param context 上下文
     * @param type 目录类型（如 Environment.DIRECTORY_DOCUMENTS）
     * @return 路径，无权限或不可用时返回null
     */
    public static File getExternalAppDir(Context context, String type) {
        if (!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            return null;
        }
        // Android 10+ 使用专属目录，无需权限
        return type != null ? context.getExternalFilesDir(type) : context.getExternalFilesDir(null);
    }

    /**
     * 保存文本到外部存储专属目录
     * @param content 文本内容
     * @param dirType 目录类型（如 Environment.DIRECTORY_DOCUMENTS）
     */
    public static boolean writeExternal(Context context, String fileName, String content, String dirType) {
        File dir = getExternalAppDir(context, dirType);
        if (dir == null || !dir.exists()) return false;

        File file = new File(dir, fileName);
        try (FileWriter writer = new FileWriter(file)) {
            writer.write(content);
            return true;
        } catch (IOException e) {
            Log.e(TAG, "外部存储写入失败: " + e.getMessage());
            return false;
        }
    }

    /*------------------------ 文件管理 ------------------------*/
    
    /**
     * 删除文件（支持内部/外部路径）
     * @param filePath 完整文件路径
     */
    public static boolean deleteFile(String filePath) {
        File file = new File(filePath);
        return file.exists() && file.delete();
    }

    /**
     * 复制文件
     * @param srcPath 源文件路径
     * @param destPath 目标文件路径
     * @return 是否成功
     */
    public static boolean copyFile(String srcPath, String destPath) {
        try (InputStream is = new FileInputStream(srcPath);
             OutputStream os = new FileOutputStream(destPath)) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = is.read(buffer)) > 0) {
                os.write(buffer, 0, length);
            }
            return true;
        } catch (IOException e) {
            Log.e(TAG, "文件复制失败: " + e.getMessage());
            return false;
        }
    }

    /*------------------------ 加密操作 ------------------------*/
    
    /**
     * AES加密后保存文件
     * @param content 明文内容
     */
    public static void saveEncrypted(Context context, String fileName, String content) {
        try {
            byte[] encrypted = encryptAES(content.getBytes(StandardCharsets.UTF_8));
            try (FileOutputStream fos = context.openFileOutput(fileName, Context.MODE_PRIVATE)) {
                fos.write(encrypted);
            }
        } catch (Exception e) {
            Log.e(TAG, "加密存储失败: " + e.getMessage());
        }
    }

    private static byte[] encryptAES(byte[] data) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(AES_KEY.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        return cipher.doFinal(data);
    }

    /*------------------------ 缓存管理 ------------------------*/
    
    /**
     * 清理应用缓存目录
     * @return 是否成功
     */
    public static boolean clearAppCache(Context context) {
        File cacheDir = context.getCacheDir();
        return deleteDir(cacheDir);
    }

    private static boolean deleteDir(File dir) {
        if (dir == null || !dir.isDirectory()) return false;
        for (File file : dir.listFiles()) {
            if (file.isDirectory()) deleteDir(file);
            else file.delete();
        }
        return dir.delete();
    }
}

 使用示例

// 1. 写入内部存储（覆盖模式）
FileUtils.writeInternal(context, "config.txt", "用户设置数据", Context.MODE_PRIVATE);

// 2. 追加内容到内部存储
FileUtils.writeInternal(context, "log.txt", "新日志条目", Context.MODE_APPEND);

// 3. 读取内部存储文件
String config = FileUtils.readInternal(context, "config.txt");

// 4. 写入加密文件
FileUtils.saveEncrypted(context, "secret.dat", "敏感数据");

// 5. 操作外部存储（Android 10+无需权限）
File docDir = FileUtils.getExternalAppDir(context, Environment.DIRECTORY_DOCUMENTS);
if (docDir != null) {
    FileUtils.writeExternal(context, "report.pdf", "PDF内容", Environment.DIRECTORY_DOCUMENTS);
}

// 6. 清理缓存
FileUtils.clearAppCache(context);

Android 获取assets的绝对路径
安卓兼职framework和app工程师的博客
03-26 2138
Android 获取assets的绝对路径 第一种方法： String path = “file:///android_asset/文件名”; 第二种方法： InputStream abpath = getClass().getResourceAsStream("/assets/文件名"); ...
android数据存储（一）
huangbaokang的博客
12-29 397
在android开发中，数据存储是项目中经常会用到的，我们需要掌握它。 其中数据存储包括 sp存储，安卓内置存储和外置存储，数据库存储，以及远程存储。除了最后一个少用，其他几个都要学会。 一、sp存储 这种存储方式适合存数据小，这个翻译就是偏好设置，一般存储一些个人信息等。以键值对的方式生成在对应目录，文件名自定义，文件后缀是固定的.xml /data/data/packageName/shared_prefs/xxx.xml 需要通过SharedPreferences接口进行操作 案例： 我们通过界
android 从assets和res中读取文件
05-11
在Android项目文件夹里面，主要的资源文件是放在res文件夹里面的。assets文件夹是存放不进行编译加工的原生文件，即该文件夹里面的文件不会像xml，java文件被预编译，可以存放一些图片，html，js, css等文件。 介绍如何读取assets文件夹的资源。
Android assets资源目录
最新发布
似霰的博客
06-20 5828
Android assets资源目录
Android开发 assets目录
weixin_30475039的博客
08-20 881
Android开发 assets目录 Android资源文件分类： Android资源文件大致可以分为两种： 第一种是res目录下存放的可编译的资源文件： 这种资源文件系统会在R.Java里面自动生成该资源文件的ID，所以访问这种资源文件比较简单，...
Android assets 目录介绍和应用
ruirui516888
06-04 310
Androidassets目录介绍和应用 说明： 1、文章转自：http://blog.toeach.net/2010/04/04/using-assets-in-android/ 2、对原文的修改：增加注释，原英文已经翻译。 3、程序经过调试验证，运行正常。 4、原文题目：Using assets in Android Android系统为每个新设计的程...
Android studio assets文件夹
谁呛我名字的博客
05-07 2590
Android studio res资源文件夹我们学习了res资源文件夹，这次我们来看看另外资源存放位置assets文件夹目录定义特点方法介绍应用场景具体用法总结assets文件夹用于存放应用程序的资产文件特点该文件夹下的文件不会被系统编译，所以无法通过R.*.*这种方式来访问。Android专门为assets目录提供了一个工具类AssetManager，通过该工具，我们能够以字节流方式打开assets下的文件，并将字节流转换为文本或者图像。
Android数据存储之SharedPreferences
08-07
- `assets`：自定义资源目录，可以存放任何类型的文件，例如数据库文件、字体文件等。 - `gen`：自动产生的Java代码目录，包含了由R.java文件，它定义了资源的ID。 通过分析这些文件，我们可以了解到一个典型的...
Android数据存储新技能：SharedPreferences读取指南
- `assets/`：非代码资源，如数据库文件、多媒体文件等，通常不包含SharedPreferences文件，因为SharedPreferences是通过API调用进行管理的。 - `lib/`：存放Java库文件，例如第三方库。 #### 实际项目中的使用场景...
Android日记本应用源码：基于SharedPreferences与Handler开发
对应压缩包中的文件夹名，表明整个工程结构清晰，遵循标准Android项目布局：包含manifest清单文件、Java/Kotlin源码目录、res资源文件夹（布局、字符串、图片等）、assets原始资源等。而“移动开发”、“源代码”...
Android数据库存储与界面跳转实现代码
压缩包内文件名为“Android端数据库存储”，虽未列出多个子文件，但可合理推测其中包含完整的Android Studio工程结构，如Java/Kotlin源码文件（可能位于com.example.databasedemo包下）、res资源目录（含布局文件、...
Android之使用Assets目录中的xml布局、网页、音乐等资源
2401_83915900的博客
03-28 441
1.当我们兴高采烈的写好demo，实机运行时，会遇到第一个坑：程序抛出了FileNotFoundException的异常通过查阅资料后你发现原来要在文件名的前面加上"assets/"的前缀2.这时你修改了你的代码，要对文件前缀进行判断if(!
Android解析XML文件（assets目录）
qq_44356236的博客
06-22 2231
安卓解析XML文件的三种方法，里面有具体的代码
android assets 在哪里,轻读一下 Android 应用开发中的 assets 目录
weixin_35823403的博客
05-29 3980
2019-08-07关键字：APK预置文件、预置配置文件、res,raw与assets的区别在Android的应用开发中，难免会遇到外部文件的预置需求。例如图像、音视频、配置文件、字体等等。对于图像，我们很容易会想到将它们存放在 res/drawable 目录或者是 res/mipmap 目录下。但对于其它类型的文件，就得另寻它法了。比较常见的可以保存任意类型文件的地方主要有两个：1、res/ra...
android assert 目录操作
04-07 7557
预前知识： Android资源文件分类： Android资源文件大致可以分为两种： 第一种是res目录下存放的可编译的资源文件： 这种资源文件系统会在R.java里面自动生成该资源文件的ID，所以访问这种资源文件比较简单，通过R.XXX.ID即可； 第二种是assets目录下存放的原生资源文件： 因为系统在编译的时候不会编译assets下
Android获取assets文件路径
热门推荐
dreamsever的专栏
05-27 6万+
我们有时候需要放置一些资源例如json，字体，视频，音频以及其他格式的资源。为了保证这些资源不被编译，以便于我们在代码中可以正常使用，我们可以放置到assets文件夹下。这个文件夹在哪呢？看下图，Android Studio新建一个项目是没有这个文件夹的，你可以在需要的时候新建这个文件夹。 我们如何使用这些文件呢？如何使用下面这一篇博客说的很详细，加载网页读取文本图片播放视频等等 http...
Android获取assets文件夹的路径
三人行，必有吾师
02-12 1201
第一种方法：        String path = "file:///android_asset/文件名"; 第二种方法：     InputStream abpath = getClass().getResourceAsStream("/assets/文件名"); 若要想要转换成String类型 String path = new String(InputStrea
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值