Android 从文件中批量导入数据，个人记录而已

最新推荐文章于 2025-09-16 02:24:54 发布
原创 最新推荐文章于 2025-09-16 02:24:54 发布 · 1.8k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文记录了使用LitePal框架在Android中批量导入大量数据的过程。通过在MyApplication中配置，利用事务处理16万条数据只需28秒。建立索引可以显著提升查找效率，未建索引需54分钟，而建索引后只需2分钟14秒。数据写入时，一次性写入JSON文件比逐条写入快5秒。数据源存放在res/raw下的ac_account文件中。

使用litePal来做为数据库的框架：

0：首先导入litepal 的依赖和fastjson的依赖

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.4.0'
    compile 'org.litepal.android:core:1.3.2'
    compile 'com.alibaba:fastjson:1.2.13'
}

1：创建一个MyApplication，

package tech.androidstudio.dbtest;

import org.litepal.LitePalApplication;

/**
 * Created by Kodulf on 2016/6/30.
 */
public class MyApplication extends LitePalApplication {
    @Override
    public void onCreate() {
        super.onCreate();
    }
}



然后修改清单文件：android:name=".MyApplication"

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="tech.androidstudio.dbtest">
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"></uses-permission>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:name=".MyApplication"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

2：在main的文件夹下面创建一个assets的文件夹，然后创建一个litepal.xml的文件，


里面的list 是我们下面的创建的类Account，就是会映射为一个表

<?xml version="1.0" encoding="utf-8"?>
<litepal>
    <dbname value="demo" ></dbname>

    <version value="1" ></version>

    <list>
        <mapping class="tech.androidstudio.dbtest.Account"></mapping>
    </list>
</litepal>

3：创建Account的类：记住一定要包含一个空的参数的构造方法，因为下面会用到FastJson转换的时候用到，不然会报错的。 

package tech.androidstudio.dbtest;

import org.litepal.crud.DataSupport;

import java.util.Date;

/**
 * Created by Kodulf on 2016/6/30.
 */
public class Account extends DataSupport {
//(uid, acc_no, realname, mobile, attribute, status, cdate, edate)
// VALUES ('20009', null, null, '18329160075', 1, 1, '2012-08-30 15:12:35', '2014-02-28 02:54:25');
    private int uid;
    private String acc_no;
    private String  realname;
    private String mobile;
    private int attribute;
    private int status;
    private Date cdate;
    private Date edate;

    public Account() {
    }

    public Account(int uid, String acc_no, String realname, String mobile, int attribute, int status, Date cdate, Date edate) {
        this.uid = uid;
        this.acc_no = acc_no;
        this.realname = realname;
        this.mobile = mobile;
        this.attribute = attribute;
        this.status = status;
        this.cdate = cdate;
        this.edate = edate;
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getAcc_no() {
        return acc_no;
    }

    public void setAcc_no(String acc_no) {
        this.acc_no = acc_no;
    }

    public String getRealname() {
        return realname;
    }

    public void setRealname(String realname) {
        this.realname = realname;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public int getAttribute() {
        return attribute;
    }

    public void setAttribute(int attribute) {
        this.attribute = attribute;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public Date getCdate() {
        return cdate;
    }

    public void setCdate(Date cdate) {
        this.cdate = cdate;
    }

    public Date getEdate() {
        return edate;
    }

    public void setEdate(Date edate) {
        this.edate = edate;
    }
}

4：修改activity_main.xml 

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:orientation="vertical"
    tools:context="tech.androidstudio.dbtest.MainActivity">

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="开始加载"
        android:onClick="doImport"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="生成json的文件"
        android:onClick="createJsonFile"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="开始加载更新后的json文件"
        android:onClick="startToImportJsonFiles"/>
    <ListView
        android:layout_width="match_parent"
        android:layout_height="300dp"
        android:id="@+id/data"></ListView>

</LinearLayout>


5：MainActivity的修改：

首先要说的是事务，通过事务，我们可以一次提交很多的数据，例如16万条的数据，只需要28秒钟，

然后如果要在保存之前进行查找是否有该数据，那么一定要建立索引，如果不建立索引，那么需要54分钟，建立了索引只需要2分钟14秒。


litepal的查找的语句是：

List<Account> accounts = DataSupport.where("uid=?", String.valueOf(uid)).find(Account.class);

类似的：

List<News> newsList = DataSupport.select("title", "content")  
        .where("commentcount > ?", "0")  
        .order("publishdate desc").limit(10).offset(10)  
        .find(News.class);

创建索引的方法：

database.execSQL("create index account_index on account(uid)");

16万数据，从数据库中读取list，然后每一行转换为JSON写入文件中，
这两个操作的时间为读取list 需要35秒，将对象转换为JSON然后写入文件中，需要12秒

写入JSON文件的操作，如果使用一次写入然后替换的话，会比一个一个的写入慢5秒钟，

//如果使用替换的话，大概需要17秒钟，比一行一行的输出慢了5分钟，开始写入jsonFri Jul 01 11:54:48 GMT+08:00 2016结束吸入JSON：Fri Jul 01 11:55:05 GMT+08:00 2016
String s = JSON.toJSONString(all);
String replace = s.replace("},{", "\n");
String replace1 = replace.replace("[{", "{");
String replaceDone = replace1.replace("]}", "}");
fileWriter.write(replaceDone);






package tech.androidstudio.dbtest;

import android.database.sqlite.SQLiteDatabase;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;

import com.alibaba.fastjson.JSON;

import org.litepal.crud.DataSupport;
import org.litepal.tablemanager.Connector;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MainActivity extends AppCompatActivity {

    private SQLiteDatabase database;
    private InputStream mInputStream;
    private Handler mhandler;
    private FileWriter fileWriter;
    private File newDBfile;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        database = Connector.getDatabase();
        mInputStream = getResources().openRawResource(R.raw.ac_account);
        mhandler = new Handler(){
            @Override
            public synchronized void handleMessage(Message msg) {
                super.handleMessage(msg);
            }
        };

    }

    public void doImportInhandler(){
        DataSupport.deleteAll(Account.class);
        int i=0;

        String sql;
        InputStream inStream=null;
        try {
            Log.d("sql",new Date().toString()+"");
            database.beginTransaction();
            inStream = mInputStream;
            BufferedReader reader=new BufferedReader(new InputStreamReader(inStream));
            while (true){
                sql=reader.readLine();
                if(TextUtils.isEmpty(sql)){
                    break;
                }
                //自己创建文件，命名为ac_account，输入如下
//                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157314', null, null, null, 0, 1, '2016-05-21 01:58:46', '2016-05-21 01:58:34');
//                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157315', null, null, null, 0, 1, '2016-05-21 01:58:47', '2016-05-21 01:58:35');
//                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157316', null, null, null, 0, 1, '2016-05-21 01:58:48', '2016-05-21 01:58:36');
//                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157317', null, null, null, 0, 1, '2016-05-21 01:58:48', '2016-05-21 01:58:36');
//                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157318', null, null, null, 0, 1, '2016-05-21 01:58:49', '2016-05-21 01:58:37');
//                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157319', null, null, null, 0, 1, '2016-05-21 01:58:50', '2016-05-21 01:58:38');

                sql=sql.replace("ac_account","account");
                database.execSQL(sql);
                i++;
//                Log.d("sql",i+"");
            }
            database.setTransactionSuccessful();
            database.endTransaction();
            Log.d("sql",new Date().toString()+"");
        }catch (Exception e){
            e.printStackTrace();
            try {
                if(inStream!=null) {
                    inStream.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }finally {
            try {
                if(inStream!=null) {
                    inStream.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
    public void doImport(View view) {
        mhandler.post(new Runnable() {
            @Override
            public void run() {
                doImportInhandler();
            }
        });
    }


    public void createJsonFile(View view) {
        mhandler.post(new Runnable() {
            @Override
            public void run() {
                try {
                    createJson();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    private void createJson() throws IOException {
        String startTime = new Date().toString();
        Log.d("kodulf","开始："+ startTime);
        String externalCacheDirPath = getExternalCacheDir().getPath();
        String externalStorageDirectoryPath = Environment.getExternalStorageDirectory().getPath();
//        File newDBfile = new File(externalCacheDirPath+"/hello.db");
        newDBfile = new File(externalStorageDirectoryPath+"/hello.db");
        fileWriter = new FileWriter(newDBfile);
        List<Account> all = new ArrayList<Account>();
        database.beginTransaction();
        try {
             all = DataSupport.findAll(Account.class);
            database.setTransactionSuccessful();
            Log.d("kodulf","执行的时候成功了");
        }catch (Exception e){
            Log.d("kodulf","执行的时候出错了");
        }
        database.endTransaction();

        Log.d("kodulf","开始："+new Date().toString());
        for (int i = 0; i < all.size(); i++) {
            String s = JSON.toJSONString(all.get(i));
            Log.d("kodulf", s);
            fileWriter.write(s);
            fileWriter.write("\n");
        }
        String endTime = new Date().toString();
        Log.d("kodulf","结束："+ endTime);
        Log.d("sql","创建JSON开始时间="+startTime+" 结束时间"+endTime);
        fileWriter.close();
    }

    public void startToImportJsonFiles(View view) {
        try {
            mInputStream = new FileInputStream(newDBfile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        Log.d("kodulf","开始执行新的从JSON格式导入的");
        mhandler.post(new Runnable() {
            @Override
            public void run() {
                doImportJSONInhandler();
            }
        });
    }

private void doImportJSONInhandler() {
        Date startDate = new Date();
        String startTime = startDate.toString();

        database.execSQL("create index account_index on account(uid)");
        DataSupport.deleteAll(Account.class);
        int i=0;

        String sql;
        InputStream inStream=null;
        try {

            Log.d("sql", startTime +"");
            database.beginTransaction();
            inStream = mInputStream;
            BufferedReader reader=new BufferedReader(new InputStreamReader(inStream));
            while (true){
                sql=reader.readLine();

                if(TextUtils.isEmpty(sql)){
                    break;
                }

                Account account = JSON.parseObject(sql, Account.class);
                //————————————————方案一，直接使用save插入，如果数据为16万条的话，大概需要26秒钟——————————————————
                //account.save();

                //+++++++++++++++方案二，在插入之前首先进行查找，如果数据为16万条的话，需要的时间会很长很长+++++++++++++++++
                // 大概需要54分钟，导入开始时间=Thu Jun 30 18:51:41 GMT+08:00 2016 结束时间Thu Jun 30 19:45:50 GMT+08:00 2016
                //int uid = account.getUid();
                //List<Account> accounts = DataSupport.where("uid=?", String.valueOf(uid)).find(Account.class);
                //if(accounts.size()==0)
                //    account.save();
                //else
                //   Log.d("json",i+" 已经有了 account"+account.toString());
                //+++++++++++++++++++++++++++++++++

                //****************方案三，使用索引的方式，然后在查找和
                //在方法最上面执行索引的操作：database.execSQL("create index account_index on account(uid)");
                //大概需要2分18秒，比第二种方案块了很多倍，导入开始时间=Thu Jun 30 20:01:45 GMT+08:00 2016 结束时间Thu Jun 30 20:04:03 GMT+08:00 2016
                int uid = account.getUid();
                List<Account> accounts = DataSupport.where("uid=?", String.valueOf(uid)).find(Account.class);
                if(accounts.size()==0)
                    account.save();
                else
                    Log.d("json",i+" 已经有了 account"+account.toString());
                i++;

            }
            database.setTransactionSuccessful();
            database.endTransaction();
            Date endDate = new Date();
            String endTime = endDate.toString();

            Log.d("sql","导入开始时间="+startTime+" 结束时间"+endTime);

        }catch (Exception e){
            e.printStackTrace();
            try {
                if(inStream!=null) {
                    inStream.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }finally {
            try {
                if(inStream!=null) {
                    inStream.close();
                }
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
    }
}




6：自己创建数据内容：

在res下面创建一个文件夹为raw。

自己创建文件，命名为ac_account，输入如下

                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157314', null, null, null, 0, 1, '2016-05-21 01:58:46', '2016-05-21 01:58:34');
                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157315', null, null, null, 0, 1, '2016-05-21 01:58:47', '2016-05-21 01:58:35');
                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157316', null, null, null, 0, 1, '2016-05-21 01:58:48', '2016-05-21 01:58:36');
                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157317', null, null, null, 0, 1, '2016-05-21 01:58:48', '2016-05-21 01:58:36');
                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157318', null, null, null, 0, 1, '2016-05-21 01:58:49', '2016-05-21 01:58:37');
                INSERT INTO ac_account (uid, acc_no, realname, mobile, attribute, status, cdate, edate) VALUES ('157319', null, null, null, 0, 1, '2016-05-21 01:58:50', '2016-05-21 01:58:38');





RK-Android11-PackageInstaller安装器自动安装功能实现
十年饮冰，难凉热血
08-20 962
通过具体需求，再次熟悉、理解 包安装器流程和业务，简单规整一些知识点，方便后续进一步深度定制。客户需求：实现下载流程和安装流程UI主题一致，安装过程去掉一些列确认弹框提示，直接进入安装流程、安装失败时候直接显示安装失败原因。 如下两图： PMS安装apk之界面跳转 MTK-Android13-包安装器PackageInstaller 静默安装实现这是之前总结、规整的包安装器知识点，平台是MTK，我们这里是在RK平台上面定制需求的，源码流程少许不一样，但思想一样，具有极高的参考价值。特别是静默安装篇，对于安
Python SQLite3 教程
m0_67394360的博客
07-29 200
要在Python中使用SQLite3，首先，您必须导入_sqlite3_模块，然后创建一个连接对象，它将我们连接到数据库并让我们执行SQL语句。要列出SQLite3数据库中的所有表，您应该查询sqlite_master表，然后使用_fetchall()_从SELECT语句中获取结果。select语句从数据库表中选择需要的数据，如果要获取选中的数据，则使用游标对象的_fetchall()_方法。关闭连接是可选的，但这是一种很好的编程习惯，因此您可以从任何未使用的资源中释放内存。...
android sqlite批量操作,Android: SQLite批量插入数据的最佳实践
weixin_29065959的博客
05-27 2157
大家都知道，Android里数据库用的是SQLite。在实际开发过程中，我们有时候会遇到批量插入数据的场景。这篇文章给大家分享一个小技巧，让批量插入数据达到最快的目的。首先，我先创建一个Table，里面只有一个字段：public static final String TABLE_NAME = "demo_data";public static final String COLUMNS_NAME ...
android批量插入数据（使用事务）
silly_wy的专栏
06-26 1067
1. 使用db.execSQL(sql) 这里是把要插入的数据拼接成可执行的sql语句，然后调用db.execSQL(sql)方法执行插入 public void inertOrUpdateDateBatch(List sqls) {            SQLiteDatabase db = getWritableDatabase();            db.be
突破性能瓶颈：LitePal批量异步插入完全指南
最新发布
gitblog_00522的博客
09-16 796
你是否还在为Android应用中大量数据插入导致UI卡顿而烦恼？是否遇到过主线程阻塞引发的ANR（Application Not Responding，应用无响应）问题？本文将系统讲解如何使用LitePal（一款轻量级Android数据库框架）的批量异步插入功能，通过10个实战案例和性能对比分析，帮助你彻底解决数据写入性能瓶颈。读完本文，你将掌握异步任务调度、批量操作优化、事务管理等核心技能，让你...
android 导入文件，获取文件内容
my_web_advanced的博客
03-18 600
方法使用说明： 传入文件路径作为参数 返回读到的内容， 字符串格式 方法说明 1.根据路径， new File 2. 使用FileInputStream类， 文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等 3. 使用BufferedReader类， 从字符输入流中读取文本并缓冲字符，以便有效地读取字符，数组和行 4. 一行一行的读文件，加到stringBuilder上； 5. stringBuilder转为字符串，返回 private static String rea
Android批量插入数据到SQLite数据库的方法
08-30
主要为大家详细介绍了Android批量插入数据到SQLite数据库的方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
android 批量插入数据
倾听雨落
04-27 2178
在开发Android应用时，有时需要把一些数据内置到应用中，常用的有以下2种方式：其一直接拷贝制作好的SQLite数据库文件，其二是使用系统提供的数据库，然后把数据批量插入。我更倾向于使用第二种方式：使用系统创建的数据库，然后批量插入数据。批量插入数据也有很多方法，那么那种方法更快呢，下面通过一个demo比较一下各个方法的插入速度。 1. 使用db.execSQL(sql) 这里是把要插入
Android Sqlite 怎么批量插入数据
weixin_42602900的博客
04-15 602
Android Sqlite 怎么批量插入数据
MySQL实战中，Insert语句的使用心得总结
2401_85112308的博客
05-28 1182
我们取10w条数据进行了一些测试，如果插入方式为程序遍历循环逐条插入。在mysql上检测插入一条的速度在0.01s到0.03s之间。逐条插入的平均速度是0.02*100000，也就是33分钟左右。下面代码是测试例子：1普通循环插入100000条数据的时间测试@Testpublic void insertUsers1() {User user = new User();user.setUserName(“提莫队长”);user.setPassword(“正在送命”);user.setPrice(3150);u
MySQL实战中，Insert语句的使用心得总结(1)
2401_84094979的博客
05-03 1087
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！若username='chenhaha’的记录不存在，REPLACE语句将插入新记录（首次充值），否则，当前username='chenhaha’的记录将被删除，然后再插入新记录。id不要给具体值，不然会影响SQL执行，业务有特殊需求除外。replace into 与 insert on deplicate udpate 比较：1、在没有主键或者唯一索引重复时，replace into 与 insert on
Android面试题整理（源自鸿洋大神公众号【201803】的一篇BAT面试题推送）
唯爱丶卡卡西的博客
04-13 2015
三月，想必各位程序员GG 此刻想要的，莫过于一篇面试宝典。鄙人不才，也从未系统的刷过面试题，以鸿洋大哥一篇面试题为引，略加整理，希望能帮到各位不知道看什么小伙伴。（大部分知识都是有答案的）. 原文链接: [https://mp.weixin.qq.com/s/p3l9wr4DX976Lr62-dYe8w(只有题)] PS：其实在推送2天后就已经全部 总结出来了，只是新的优快云 编辑器排版不会...
android 插入数据,android批量插入数据效率对比
weixin_34761438的博客
05-29 284
对比在android中批量插入数据的3中方式对比(各插入1W条数据所花费的时间)：1、 一个一个插入Java代码/***向表中插入数据**@paramopenHelper*@paramappInfo*@return*/publicstaticbooleaninsert(SQLiteOpenHelperopenHelper,RemoteAppInfoappInfo){if(...
如何把批量数据导入到android 的 sqlite 数据库（转）
weixin_30293135的博客
02-29 136
SQLite 数据库需要放在目录中的databases folder，我们可以使用“adb shell” 的 “mkdir”来创建这个文件夹。 #ls lib #mkdir databases #ls databases lib 默认创建的"databases"仅供 "root"权限访问，而在Android平台中，我们启动的每个“Activity”都是使用不同的“user”权...
Android批量插入数据到SQLite数据库
Ashliker的专栏
10-12 270
Android批量插入数据到SQLite数据库 https://blog.youkuaiyun.com/suyimin2010/article/details/88755819
Android 数据库 大量插入 事务开启
主人公的专栏
07-03 3704
对比在android中批量插入数据的3中方式对比（各插入1W条数据所花费的时间）：1、 一个一个插入 publicstaticboolean insert(SQLiteOpenHelper openHelper, RemoteAppInfo appInfo) { if (null == appInfo) { returntr
Android Studio导入太慢？修改项目配置文件再导入，飞一般的感觉
热门推荐
我早就想，要这样载着你，翻山越岭
07-01 1万+
你是否有这样的经历： 在Github或者从别人哪儿拷贝一个项目过来，编译半天编译不过去，进度条一直在转，也没个提示来告诉咱们具体错误原因是啥，内心崩溃得不要不要的。我大概总结了下使用Android Stuido去加载一个项目，需要的环境包括： Gradle，包括Gradle使用版本和Android插件版本 JDK，这个所有的Java程序都需要 Compile Sdk—需要的Android SDK
Android 往Sqlitedatabase中插入大量数据效率问题，40倍效率加速你的操作
Gpwner的博客
11-27 8023
情景：我现在要往sqlite database中的表中（R_USER_QUESTION_DO_HISTORY）插入一万条数据1.我的代码： public void setUpDataBaseForUser(String userID) { String[] column = { Config.COLUMN_USERID, };
Android Studio中LitePal使用
red_ear的博客
01-17 2259
1. 首先，新建一个litepal的空项目 2. 布局（几个基本按钮）activity_main.xml <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_...
Android平台Excel表格数据导入导出技术解析
在Android开发中，将数据转化为Excel表格...例如，用户可能需要将他们的日常开支记录导出到Excel文件中进行分析，或者将已有的Excel格式的账单数据导入到应用中以便跟踪其财务状况。这说明了此类功能的实际应用价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值