精华内容
下载资源
问答
  • SharedPreferences是一种轻量级的存储方式,通过存为键值对保存为xml文件来存放读取数据,文件路径在data/data/程序包名/share_prefs目录下,只适合存储一些简单参数配置; 2.文件存储(三级缓存中的磁盘缓存) ...

    1.SharedPreference

    SharedPreferences是一种轻量级的存储方式,通过存为键值对保存为xml文件来存放读取数据,文件路径在data/data/程序包名/share_prefs 目录下,只适合存储一些简单参数配置;

    1.不要存放大的key和value在SharedPreferences中,否则会一直存储在内存中得不到释放,内存使用过高会频发引发GC,导致界面丢帧甚至ANR。

    2.不要每次都edit,因为每次都会创建一个新的EditorImpl对象,最好是批量处理统一提交。否则edit().commit每次创建一个EditorImpl对象并且进行一次IO操作,严重影响性能。

    2.文件存储(三级缓存中的磁盘缓存)

    网络下载文件后,保存到文件缓存中。最好的三级缓存策略:先读取内存缓存(LruCache算法,很多框架都封装过),没有找到再查找磁盘缓存,最后没找到再请求网络;

    。。IO操作

     

    上述是读取内存卡中的缓存,如果读取外部SD卡,需要在原来读写逻辑前先判断Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) 是否为true,才能开始读写;

     

    3.网络存储(三级缓存中的网络缓存)

    通过网络请求直接下载的文件,直接走Http  conn.getInputStream() 拿到输入流,通过输入流把文件读取出来;

     

    4.ContentProvider

     

    展开全文
  • Android持久化存储的几种方式

    千次阅读 2017-12-12 16:05:36
    Android开发中,数据的持久化是肯定会用到,而持久化的方法大致有五种,分别是文件存储、网络存储、SharedPreferences、Sqlit数据库存储和ContentProvider。

    在Android开发中,数据的持久化是肯定会用到,而持久化的方法大致有五种,分别是文件存储、网络存储、SharedPreferences、Sqlit数据库存储和ContentProvider。这五种存储方式各有各的优点,下面我将一一对它们进行介绍。

    1.文件存储

    在应用开发中有一个场景,就是从网络中加载图片。我们知道,网络请求都需要时间,如果网络速度不够快,或者没有网络将会造成图片加载速度慢、甚至无法加载成功的问题。在Android中的处理方式其实是对已加载的图片进行一个缓存,包括内存缓存和硬盘缓存两种方式。而硬盘缓存就是运用了在本地文件存储的方式。
    我们来看一段代码。

    public void getImage(String url){
            //从url网络路径解析出文件的名字。
            filename=url.substring(url.lastIndexOf("/")+1,url.length());
            File file_ima=new File(file_url+filename);
            //判断文件是不是存在
            if(file_ima.exists()){
            //存在直接从本地加载
                Toast.makeText(getApplication(),"从本地加载",Toast.LENGTH_LONG).show();
                iv_ima.setImageBitmap(BitmapFactory.decodeFile(file_url+filename));
                return;
            }
            //不存在的话,使用下载线程,对图片进行下载,进行存储。
            DownloadFile thread=new DownloadFile(mHandler,url,file_url+filename);
            thread.start();
    }

    上面代码,是通过对传入图片的网络路径对图片的名字进行解析,判断该图片在本地文件中是否存在,如果存在,则直接从本地加载。而如果不存在则会调用网络线程对图片进行加载。

    public class DownloadFile extends Thread
    {
        Handler mHandler;
        String mUrl;
        String mPath;
        public DownloadFile(Handler handler, String url, String path){
            mHandler=handler;
            mUrl=url;
            mPath=path;
        }
    
        @Override
        public void run()
        {
            super.run();
            downLoadFromUrl(mUrl,mPath);
        }
    
        public  void downLoadFromUrl(String urlStr, String path) {
            if(urlStr==null){
                return;
            }
            URL url = null;
            try {
                url = new URL(urlStr);
                Log.e("music", urlStr);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                //设置超时间为3秒
                conn.setConnectTimeout(3 * 1000);
                //防止屏蔽程序抓取而返回403错误
                //conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
                //得到输入流
                InputStream inputStream = conn.getInputStream();
                //获取自己数组
                byte[] getData = new byte[1024];
                //文件保存位置
                File saveDir = new File(Environment.getExternalStorageDirectory().toString()+"/test_1/");
                Log.e("jdjj",Environment.getExternalStorageDirectory().toString()+"/test_1/");
                if (!saveDir.exists()) {
                    saveDir.mkdirs();
                }
                File file = new File(path);
                //打开文件输出流
                FileOutputStream fos = new FileOutputStream(file);
                int i=0;
                int count=0;
                //从输入流里读出,通过输出流写入文件。
                while ((count=inputStream.read(getData))!=-1) {
                    fos.write(getData,0,count);
                }
                fos.flush();
                if (fos != null) {
                    //输出流关闭
                    fos.close();
                }
                if (inputStream != null) {
                    //输入流关闭
                    inputStream.close();
                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            Message message=new Message();
            mHandler.sendMessage(message);
    
        }
    }

    上面代码也就是网络加载图片的代码。首先是创建一个HttpURLConnection的连接。
    为连接做相应的配置。然后通过该连接得到输入流,根据文件路径和文件名,创建一个文件输出流。将字节流写入本地文件。这就完成了对网络图片的本地存储。在一次加载图片的时候,就不会再去进行网络请求,节约了时间与流量。其实在真正图片缓存实现中,并没有这么简单,硬盘缓存文件也与内存缓存一样,有相应的大小和管理机制。有机会我和写一篇图片的三级缓存机制。
    我们来看看效果。
    点击按钮,第一次加载时从网络加载。
    这里写图片描述
    关闭网络再点击一次。就会从本地加载。
    这里写图片描述

    由此可见,本地文件存储方式可以用来存储图片、歌曲等各种格式的文件,防止重复从网络加载。

    2.网络存储

    网络存储是网络应用开发中必不可少部分。比如说每个用户的个人资料,都会在远程的服务器中存储一份,这样才能保证在不同的终端都可以登陆和获取到每个用户的个人资料。
    网络存储自然离不开数据和文件的上传,对于用户的基本资料,我们可以把信息封装成Json数据进行上传。对于大文件来说我们需要通过HTTP来进行上传。
    1.使用volley框架上传json数据。

    HashMap insertnmap = new HashMap();
    //将数据封装,转为json数据
    insertnmap.put("phonenum", tephone);
    insertnmap.put("name", name);
    insertnmap.put("password", password);
    JSONObject jsonObject = JSONObject.fromObject(insertnmap); 
    //使用volley框架,设置为post请求方式,上传Json数据
    RequestQueue queue = Volley.newRequestQueue(mContext);
    JsonObjectRequest sr = new JsonObjectRequest(Method.POST,url1, jsonObject, new com.android.volley.Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject jsonObject) {
    
                }
            }, new com.android.volley.Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError volleyError) {
    
                }
            });
    queue.add(sr); 
    

    在服务器端,对json数据进行解析,然后存储在数据库中。

    2.上传文件,使用http。

    public class UploadFile extends Thread {
        final int EVENT_POST_START =1;
        final int EVENT_POST_FAILED =2;
        final int EVENT_POST_SUCCESS =3;
        private Handler mUpdateHandler;
        private String uploadUrl;
        private String srcPath;
    
        public UploadFile(Handler handler,String uploadUrl,String srcPath){
            mUpdateHandler = handler;
            this.uploadUrl = uploadUrl;
            this.srcPath = srcPath;
        }
        @Override
        public void run() {
            super.run();
            mUpdateHandler.sendEmptyMessage(EVENT_POST_START);
            String end = "\r\n";
            String twoHyphens = "--";
            String boundary = "******";
            try {
                URL url = new URL(uploadUrl);
                HttpURLConnection httpURLConnection = (HttpURLConnection) url
                        .openConnection();
                // 允许输入输出流
                httpURLConnection.setDoInput(true);
                httpURLConnection.setDoOutput(true);
                httpURLConnection.setUseCaches(false);
                // 使用POST方法
                httpURLConnection.setRequestMethod("POST");
                httpURLConnection.setRequestProperty("Connection", "Keep-Alive");
                httpURLConnection.setRequestProperty("Charset", "UTF-8");
                httpURLConnection.setRequestProperty("Content-Type",
                        "multipart/form-data;boundary=" + boundary);
                //打开输出流,配置数据头
                DataOutputStream dos = new DataOutputStream(
                        httpURLConnection.getOutputStream());
                dos.writeBytes(twoHyphens + boundary + end);
                dos.writeBytes("Content-Disposition: form-data; name=\"uploadedfile\"; filename=\""
                        + srcPath.substring(srcPath.lastIndexOf("/") + 1)
                        + "\""
                        + end);
                dos.writeBytes(end);
                //打开当前文件输入流
                FileInputStream fis = new FileInputStream(srcPath);
                byte[] buffer = new byte[8192]; // 8k
                int count = 0;
                // 读取文件,写入服务器中
                while ((count = fis.read(buffer)) != -1) {
                    dos.write(buffer, 0, count);
                }
                //关闭输入流
                fis.close();
                //配置数据
                dos.writeBytes(end);
                dos.writeBytes(twoHyphens + boundary + twoHyphens + end);
                dos.flush();
                //打开网络输入流 
                InputStream is = httpURLConnection.getInputStream();
                InputStreamReader isr = new InputStreamReader(is, "utf-8");
                BufferedReader br = new BufferedReader(isr);
                String result = br.readLine();
                mUpdateHandler.sendEmptyMessage(EVENT_POST_SUCCESS);
                //关闭输出流与输入流
                dos.close();
                is.close();
    
            } catch (Exception e) {
                mUpdateHandler.sendEmptyMessage(EVENT_POST_FAILED);
                e.printStackTrace();
            }
        }
    }

    3.SharedPreferences

    SharedPreferences是一种轻量型的存储方式,他适合用于存储一些简单的参数配置。比如说在游戏中是否打开声音、上一次登录的账号等,这些都可以用SharedPreferences来实现。其实SharedPreferences的原理是使用xml文件来存放数据。比如说我们在res/values下新建一个setting.xml文件。文件内容如下:

    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="number"></string>
        <string name="music"></string>
    </resources>

    具体使用步骤:

    public class LoginActivity extends AppCompatActivity
    {
    
        Button bt_login;
        RadioButton rb_music;
        EditText et_pass;
        EditText et_num;
        //声明SharedPreferences,用来读取xml;
        SharedPreferences sp;
        //声明SharedPreferences.Editor,用来修改xml里面的值。
        SharedPreferences.Editor ed;
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_login);
            //与相应的xml文件建立连接,第二个参数是打开的方式。如果不存在将创建。
            sp=getSharedPreferences("setting",MODE_WORLD_READABLE);
            et_num=(EditText)findViewById(R.id.et_num);
            et_pass=(EditText)findViewById(R.id.et_pass);
            rb_music=(RadioButton)findViewById(R.id.rb_music);
            //直接使用getxxxx方法来获取xml中指定key的值,第二个参数是当不存在这个数据时,会返回的值
            if(sp.getString("music","否").equals("是")){
                rb_music.setChecked(true);
                et_num.setText(sp.getString("number",""));
            }else {
                rb_music.setChecked(false);
            }
            bt_login=(Button)findViewById(R.id.bt_login);
            bt_login.setOnClickListener(new View.OnClickListener()
            {
                @Override
                public void onClick(View v)
                {
                    //得到指定xml的SharedPreferences.Editor
                    ed=sp.edit();
                    if(rb_music.isChecked()){
                        //修改指定xml的值
                        ed.putString("music","是");
                        ed.putString("number",et_num.getText().toString());
                    }else {
                        ed.putString("music","否");
                        ed.putString("number","");
                    }
                    //记住,这里一定要commit才能生效。
                    ed.commit();
                }
            });
    
        }
    }

    具体使用方法都在上面代码中可以看到,这里要提一点,在打开指定xml时,调用了getSharedPreferences(“setting”,MODE_WORLD_READABLE)这个方法,其中第一个就是当前要打开xml的名字。而第二个参数就是以什么样的方式打开xml,一共有四种方式:
    1. MODE_APPEND: 追加方式存储
    2. MODE_PRIVATE: 私有方式存储,其他应用无法访问
    3. MODE_WORLD_READABLE: 表示当前文件可以被其他应用读取
    4. MODE_WORLD_WRITEABLE: 表示当前文件可以被其他应用写入
    如果采用3与4两种方式创建或打开的话。这个Preferences将可以被其他应用打开,打开的时候其他应用需要得到当前应用的Context。然后通过Context.getSharedPreferences()打开。

    4.Sqlit数据库存储和ContentProvider

    为什么要将Sqlit与ContentProvider放一起呢?首先我们说说什么是ContentProvider:

    ContentProvider
    ContentProvider属于Android四大组件之一。从名字上来翻译的话,叫做内容提供者。它的作用主要是用来与其他应用进行数据交互的。举个列子来说,在QQ中拥有一个日程的入口,进入后我们可以在日历上标注某个日子的备注,用来提醒自己。然后我们打开系统的日历,发现刚才在qq中添加的备注,日历上也得到了显示。其实在这里就可以使用ContentProvider来完成。
    所以就如同上面所说,如果我们希望得到其他应用的一些私密数据,而且其他应用愿意给我们提供这些数据的话,我们就可以使用ContentProvider这个组件来完成这个功能。
    那么ContentProvider与sqlit有什么关系呢?其实ContentProvider只是用来提供内容或者修改内容的接口。而具体如何去获取数据、去哪里获取数据我们还是需要依靠其他的数据获取的方式。在ContentProvider内部,我们可以通过网络去得到当前应用的用户资料,可以通过SharedPreferences得到当前应用的配置,也可以通过文件来得到某些资源。所以它当然也可以通过Sqlit来操作底层的数据库。
    因此我想将ContentProvider与sqlit数据库一起来讲,方便大家理解与使用。
    具体请看下一篇文章:ContentProvider封装sqlit数据库

    展开全文
  • Android系统中主要提供了三种方式用于简单的实现数据持久化功能: 文件存储(手机自带的内存)、SharedPreferences存储以及数据库存储, 当然还可以用sd卡存储 1,文件存储 特点:手机自带的内存,只能供当前...

    Android系统中主要提供了三种方式用于简单的实现数据持久化功能:

    文件存储(手机自带的内存)SharedPreferences存储以及数据库存储, 当然还可以用sd卡存储

    1,文件存储

    特点:手机自带的内存,只能供当前应用程序访问,其他应用程序访问不了,程序卸载这些数据也会随着消失

    原理:
    基本是先获取一个文件的输出流,然后把信息write进去,最后关闭流
    a,通过上下文类context的openFileOutput()方法获得一个FileOutputStream输出流
    b,要写入的内容通过write()写到FileOutputStream对象
    c,关闭流
    openFileOutput()可以将数据存储到指定的文件中,方法有两个参数,第一个参数是文件名,不需要带上完整的路径,因为这里都是默认存储到data/data/file下面的

    第二个参数是文件的操作模式,两种:MODE_PRIVATE和MODE_APPEND.前者是覆盖,后者是追加
    (MODE_WORLD_READABLE和MODE_WORLD_WRITEABLE,前者是允许只读,后者是只写,但是都被抛弃,因为不安全)
    [java] view plain copy
    1. private void save(String inputText ) {  
    2.            FileOutputStream fos = null;  
    3.            BufferedWriter writer = null;  
    4.             try {  
    5.                fos = openFileOutput( "data", Context.MODE_PRIVATE);  
    6.                writer = new BufferedWriter( new OutputStreamWriter(fos));  
    7.                 writer.write( inputText);  
    8.            } catch (IOException e) {  
    9.                  // TODO Auto-generated catch block  
    10.                  e.printStackTrace();  
    11.            } finally {  
    12.                  try {  
    13.                       if( writer != null)  
    14.                             writer.close();  
    15.                 }catch (IOException e) {  
    16.                       // TODO Auto-generated catch block  
    17.                       e.printStackTrace();  
    18.                 }  

    主要的就是上面的三句话
    openFileOutput打开一个输出流,然后构建一个字节缓冲流对象然后写数据,

    此外还有几个方法需要特别注意一下 ,这几个方法对于文件关系提供了更好的支持,配合上面介绍的方式, 就可以对文件的数据进行常规的CRUD操作 (增删改查),方法如下:
    File getFIlesDir ():获取文件系统的绝对路径。
    boolean deleteFile(String name):删除一个指定文件名为name的文件。
    String[] fileList() :当前应用内部存储路径下的所有文件名。

    [java] view plain copy
    1.  //帮助我们返回一个目录  
    2.   //context.getCacheDir ()的话就是保存到cache缓存文件夹下面       
    3. File file=new File(context.getFilesDir(), "userinfo.txt");             
    4.        FileOutputStream fos= new FileOutputStream( file);            
    5.             //zhangsan 123  
    6.             fos.write(( username+ "##"+ password).getBytes());  
    7.             fos.close();  



    2、sharedpreference 存储(一般用于保存用户设置偏好);

    特点如下:

    @1以键值对的形式保存到data/data/应用程序包名/shared_prefs目录的XXX.xml文件中

    @2目前支持的数据类型有String int float boolean long

    @3不支持自定义的Object

    @4通常用来存储App上的用户配置信息.如:是否震动,是否打开背景音乐 小游戏积分 用户账号密码信息

    @5 在一些需要缓存的页面数据的情况在,比如一个首页的列表数据,在不需要对列表数据进行增删改的情况下(一般app的页面数据缓存仅需要查询功能),可以取巧使用sp来保存json数据,再利用fastjson,gson等格式化工具来恢复数据。


    要使用该方法来存储数据就要先获得一个SharedPreferences对象,有三种获取方法
    a,Context上下文类中的getSharedPreferences
    两个参数,第一个是指定文件的名称,不在就创建。目录也是在data/data/包名/shared_prefs目录下
    第二个参数是操作模式。MODE_PRIVATE是默认的,只允许当前的应用程序对其进行操作,MODE_MULTI_PROCESS是一般用于有多个进程中对同一个SharedPreferences文件进行读写的情况,同样有MODE_WORLD_WRITEABLE MODE_WORLD_READABLE两个被废弃的模式
    b,Activity类中的getPreferences
    只有一个参数,也是操作模式,文件的名称是默认的当前活动的类名
    c,PreferenceManager管理类中的getDefaultSharedPreferences()
    管理类中的一个静态方法,接收一个context参数,自动把当前的包名作为文件命名的前缀

    得到一个对象之后,有三步来进行数据的存储
    1,调用对象的edit方法获得一个SharedPreferences.Editor对象
    2,向.Editor对象添加数据,putBoolean()或者是putString(),,等等putXXX()方法
    3,调用commit方法将添加的数据提交,完成数据的存储操作

    例子:
    [java] view plain copy
    1. @Override  
    2. public void onClick(View v) {  
    3.       // TODO Auto-generated method stub  
    4.  SharedPreferences.Editor editor=getSharedPreferences( "data", MODE_PRIVATE).edit();  
    5.              editor.putString( "name""HuaAn");  
    6.              editor.putInt( "id"9527);  
    7.              editor.putBoolean( "婚否"false );  
    8.              editor.commit();          
    9.            }  
    10.      });  

    最后的结果是以xml的方式存在内存中的


    从SharedPreferences中读取数据 SharedPreferences提供了许多的get方法来进行获取数据,都和相应的put方法对应
    get方法也是有两个参数,第一个“键”,第二个是键找不到值时候的默认值,自己设定把
    还是继续取出上面存储的xml数据文件的数据 
    [java] view plain copy
    1. restore_button .setOnClickListener(new OnClickListener() {             
    2.             @Override  
    3.             public void onClick(View v) {  
    4.                  // TODO Auto-generated method stub  
    5.    SharedPreferences  pref=getSharedPreferences( "data", MODE_PRIVATE);  
    6.              
    7.            String name= pref.getString( "name""HuaAn");  
    8.             int id= pref.getInt( "id"9527);  
    9.             boolean married= pref.getBoolean( "婚否"false ); 
    10.            }  
    11.      });  
    12.      }  


    3 ,SQLite数据库存储

    为方便管理数据库有一个专门的抽象类SQLiteOpenHelper,它有两个抽象的方法onCreate()和onUpdate()
    此外还有两个实例方法,getReadableDatabase()和getWritableDatabase(),都可以创建或者是打开一个现有的数据库(存在就打开,不在就创建),返回一个可对数据库进行操作的对象
    当数据库不可写入的时候,前者返回的是一个只能读的方式打开数据库,后者则会出现异常

    数据库文件同样还是会放在data/data/包名/databases下面

    实现步骤如下:

    1,构建SQLiteOpenHelper的实例,也就是完成其构造函数(参数一是context,第二个是要创建的数据库的名字,第三个是cursor,一般是null,第四个是数据库的版本号)
    2,再调用getReadableDatabase()或者getWritableDatabase()方法创建数据库
    同时重写onCreate()方法,该方法也会得到执行
    例子:

    [java] view plain copy
    1. public class MyDatabaseHelper extends SQLiteOpenHelper {  
    2. /* 
    3. 补充一下建表的一些类型 
    4. integer ---整型 
    5. real-----浮点类型 
    6. text---文本类型 
    7. blob---二进制类型 
    8.  
    9. */  
    10. public static final String CREATE_BOOK= "create table book(id integer primary key autoincrement,"  
    11.            + "author text"  
    12.            + "price real"  
    13.            + "pages integer"  
    14.            + "name text)";   
    15.      private Context mContext ;  
    16.   
    17.      public MyDatabaseHelper(Context context, String name,  
    18.                 CursorFactory factory, int version) {  
    19.             super( context, name, factory, version);  
    20.             // TODO Auto-generated constructor stub  
    21.             mContext= context;  
    22.      }  
    23.   
    24.      @Override  
    25.      public void onCreate(SQLiteDatabase db) {  
    26.             // TODO Auto-generated method stub  
    27. //执行建表语句  
    28.     db.execSQL(CREATE_BOOK);  
    29.     Toast.makeText(mContext , "数据库创建成功" , Toast.LENGTH_SHORT).show();  
    30.      }  
    31.   
    32.      @Override  
    33.      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
    34.             // TODO Auto-generated method stub  
    35.      }  
    36. }  

    1. dbHelper= new MyDatabaseHelper( this"BookStore.db"null1);  
    2.      Button createDatabase=(Button) findViewById(R.id.create_database );  
    3.      createDatabase.setOnClickListener( new OnClickListener() {  
    4.              
    5.             @Override  
    6.             public void onClick(View v) {  
    7.                  // TODO Auto-generated method stub  
    8.                  dbHelper. getWritableDatabase();  
    9.            }  
    10.      });  

    public long insert (String table, String nullColumnHack, ContentValues values)

    Added in API level 1

    Convenience method for inserting a row into the database.

    Parameters
    table the table to insert the row into
    nullColumnHack optional; may be null. SQL doesn't allow inserting a completely empty row without naming at least one column name. If your provided values is empty, no column names are known and an empty row can't be inserted. If not set to null, thenullColumnHack parameter provides the name of nullable column name to explicitly insert a NULL into in the case where your values is empty.
    values this map contains the initial column values for the row. The keys should be the column names and the values the column values
    Returns
    • the row ID of the newly inserted row, or -1 if an error occurred
    [java] view plain copy
    1. Button addData =(Button) findViewById(R.id. add_data);  
    2.       addData.setOnClickListener( new OnClickListener() {           
    3.             @Override  
    4.             public void onClick(View v) {  
    5.                  // TODO Auto-generated method stub  
    6.                 SQLiteDatabase dbOperate= dbHelper.getWritableDatabase();  
    7.                 ContentValues values= new ContentValues();  
    8.             //下面没有给表中的id赋值,因为在建表的时候,id是默认自动增长的  
    9.                  //添加第一条记录到Book  
    10.                  values.put( "name""安卓入门之路" );  
    11.                  values.put( "author""hl174");  
    12.                  values.put( "pages"800);  
    13.                  values.put( "price"50);                 
    14.                  dbOperate.insert( "book"null, values);  
    15.                   
    16.                  values.clear();  
    17.                   
    18.                  //插入第二条记录到book  
    19.                  values.put( "name""安卓精通" );  
    20.                  values.put( "author""hl174");  
    21.                  values.put( "pages"700);  
    22.                  values.put( "price"45);       
    23.               dbOperate.insert( "book"null, values);  
    24.            }  
    25.      });  

    更新数据:
    update():四个参数

    public int update (String table, ContentValues values, String whereClause, String[]whereArgs)

    Added in API level 1

    Convenience method for updating rows in the database.

    Parameters
    table the table to update in
    values a map from column names to new column values. null is a valid value that will be translated to NULL.
    whereClause the optional WHERE clause to apply when updating. Passing null will update all rows.
    whereArgs You may include ?s in the where clause, which will be replaced by the values from whereArgs. The values will be bound as Strings.
    Retu rns
    • the number of rows affected
    第一个参数:表名  第二个参数:ContentValues对象,
    最后两个参数是用来约束更新某一行或几行中的数据,不指定的话就是更新所有行
    [java] view plain copy
    1. //更新数据  
    2.      Button updateData=(Button) findViewById(R.id. update_data);  
    3.       updateData.setOnClickListener( new OnClickListener() {  
    4.             @Override  
    5.             public void onClick(View v) {  
    6.                  // TODO Auto-generated method stub  
    7.                 SQLiteDatabase db= dbHelper.getWritableDatabase();  
    8.                 ContentValues values= new ContentValues();  
    9.                  values.put( "price"10000);  
    10.                   
    11.         db.update( "book", values, "name=?"new String[]{"安卓入门之路" });  
    12.            }  
    13.      });  
    上面第三个参数对应的是类似sql中的where语句,?是一个占位符,第四个参数的内容可以替换掉该占位符



    删除数据
    很明显,删除数据就是delete()方法了

    public int delete (String table, String whereClause, String[] whereArgs)

    Added in API level 1

    Convenience method for deleting rows in the database.

    Parameters
    table the table to delete from
    whereClause the optional WHERE clause to apply when deleting. Passing null will delete all rows.
    whereArgs You may include ?s in the where clause, which will be replaced by the values from whereArgs. The values will be bound as Strings.
    Returns
    • the number of rows affected if a whereClause is passed in, 0 otherwise. To remove all rows and get a count pass "1" as the whereClause.
    三个参数:第一个是表名
    第二个第三个同样是进行约束的条件行
    [java] view plain copy
    1. //删除数据  
    2.      Button deleteData=(Button) findViewById(R.id. delete_data);  
    3.       deleteData.setOnClickListener( new OnClickListener() {        
    4.             @Override  
    5.             public void onClick(View v) {  
    6.                  // TODO Auto-generated method stub  
    7.                 SQLiteDatabase db= dbHelper.getWritableDatabase();  
    8.                  //删除页数大于500的记录  
    9.                  db.delete( "book""pages>?"new String[]{"500" });  
    10.            }  
    11.      });  



    查询语句
    CRUD中其实用的最多的还是查询语句
    同样SQLiteDatabase也提供了query()方法,但是这个方法有好多个参数的类型,看最少的参数为7个

    public Cursor query (String table, String[] columns, String selection, String[]selectionArgs, String groupBy, String having, String orderBy)

    Added in API level 1

    Query the given table, returning a Cursor over the result set.

    Parameters
    table The table name to compile the query against.
    columns A list of which columns to return. Passing null will return all columns, which is discouraged to prevent reading data from storage that isn't going to be used.
    selection A filter declaring which rows to return, formatted as an SQL WHERE clause (excluding the WHERE itself). Passing null will return all rows for the given table.
    selectionArgs You may include ?s in selection, which will be replaced by the values from selectionArgs, in order that they appear in the selection. The values will be bound as Strings.
    groupBy A filter declaring how to group rows, formatted as an SQL GROUP BY clause (excluding the GROUP BY itself). Passing null will cause the rows to not be grouped.
    having A filter declare which row groups to include in the cursor, if row grouping is being used, formatted as an SQL HAVING clause (excluding the HAVING itself). Passing null will cause all row groups to be included, and is required when row grouping is not being used.
    orderBy How to order the rows, formatted as an SQL ORDER BY clause (excluding the ORDER BY itself). Passing null will use the default sort order, which may be unordered.
    Returns
    • Cursor object, which is positioned before the first entry. Note that Cursors are not synchronized, see the documentation for more details.
    See Also
    1:表名
    2:要查询的是哪几列,不指定的话就是默认查询所有列
    3、4:约束某一行或者是某几行的数据,不指定则默认是查询所有的数据
    5,groupby指定的列,不指定这项参数就相当于跳过
    6,having是对group之后的数据进行过滤
    7可以指定查询结果的排序方式

    当然调用query之后会返回一个Cursor对象,查询到的数据都将从这个对象中取出
    [java] view plain copy
    1. public void onClick(View v ) {  
    2.           // TODO Auto-generated method stub  
    3.        SQLiteDatabase db= dbHelper.getWritableDatabase();  
    4.         //查询book表中的所有数据  
    5.  Cursor cursor=  db.query( "book"nullnullnullnullnullnull);  
    6.    if( cursor.moveToFirst()){  
    7.           do{  
    8.              //遍历cursor对象,取出数据并打印  
    9.          String name= cursor.getString( cursor.getColumnIndex( "name"));  
    10.        String author= cursor.getString( cursor.getColumnIndex( "author"));  
    11.      int pages= cursor.getInt( cursor.getColumnIndex( "pages"));  
    12.      double price= cursor.getDouble( cursor.getColumnIndex( "price"));  
    13.                              
    14.          Log. d("MainActivity" , "书名是:" +name );  
    15.          Log. d("MainActivity" , "书的作者是:" +author );  
    16.          Log. d("MainActivity" ,"书的页数是:" +pages );  
    17.          Log. d("MainActivity" , "书的价钱是:" +price );  
    18.           } while( cursor.moveToNext());  
    19.          }  
    20.      cursor.close();  
    21.     }  
    22.   });  
    首先是通过db.query得到cursor对象,在cursor类中我们发现了下面的一些方法,getString,getDouble,getInt等但是都需要传一个参数进去,也就是所在列的下标,从0开始计数
    要得到相应列所在的下标同样有方法getColumnIndex(String columnName),这样的话先得到列所在的下标,然后通过该下标得到相应的记录值



    public abstract int getColumnIndex (String columnName)

    Added in API level 1

    Returns the zero-based index for the given column name, or -1 if the column doesn't exist. If you expect the column to exist use getColumnIndexOrThrow(String) instead, which will make the error more clear.

    Parameters
    columnName the name of the target column.
    Returns
    • the zero-based column index for the given column name, or -1 if the column name does not exist.
    展开全文
  • Android的数据存储方式有五种 一、SharedPreferences 是一种轻型的数据存储方式 本质是基于XML文件存储key-value键值对数据 通常用来存储一些简单的配置信息 SharedPreference对象本身只能获取数据而不支持存储...

    Android的数据存储方式有五种

    一、SharedPreferences

    1. 是一种轻型的数据存储方式
    2. 本质是基于XML文件存储key-value键值对数据
    3. 通常用来存储一些简单的配置信息
    4. SharedPreference对象本身只能获取数据而不支持存储和修改,存储修改是通过Editor对象实现

    二、SQlite

     

    1. 支持高达2TB大小的数据库
    2. 以单个文件形式存在
    3. 以B-Tree数据结构的形式存储在磁盘
    4. 特点: (1)轻量级(2)独立性(3)隔离性(4)跨平台(5)多语言支持

    三、File

    四、ContentProvide

    五、网络存储

     

     

     

    展开全文
  • xmlns:tools="http://schemas.android.com/tools" ... android:layout_width="match_parent"  android:layout_height="match_parent"  android:paddingBottom="@dimen/activity_vertical_margin"  andr
  • Android中数据持久化实现方式分为内部存储、外部存储、及网络数据,本章节根据数据持久化的方式对数据的存和取进行一一讲解。 二:数据持久化方式 1:内部存储 内部存储方式创建的所有文件都在和应用包名相同的...
  • Android数据持久化存储

    千次阅读 2016-05-05 14:51:19
    Android数据持久化存储共有四种方式,分别是文件存储、SharedPreferences、Sqlite数据库和ContentProvider。在本篇幅中只介绍前面三种存储方式,因为ContentProvider属于android四大组件之一,所以它的数据存储方式...
  • 本文实例讲述了Android持久化技术之SharedPreferences存储。分享给大家供大家参考,具体如下: 1、SharedPreferences存储 在前面一篇文章《Android持久化技术之文件的读取与写入实例详解》中,我们介绍了Android持久...
  • 持久化技术提供了一种机制可以让数据在瞬时状态和持久状态之间进行转换Android 系统提供了 3 种方式用于简单地实现数据持久化功能,即 文件存储,SharePreference存储 和 数据库存储。1.文件存储最基本的存储方式,...
  • 瞬时数据 瞬时数据是指那些存储在...Android系统主要提供了3种方式用于简单地实现数据持久化功能 文件存储 SharedPreferences 数据库存储 手机SD卡(前三种比较简单,这一种是比较安全) 文件存储 将数据存储到文件中
  • Android数据持久化存储共有四种方式,分别是文件存储、SharedPreferences、Sqlite数据库和ContentProvider。在本篇幅中只介绍前面三种存储方式,因为ContentProvider属于android四大组件之一,所以它的数据存储方式...
  • 前言之前一直在讲AndroidUI的内容,但是还没有完结,之后会慢慢补充。今天讲讲其他的,关于数据持久化...在Android中,可以使用几种方式实现数据持久化:Shared Preferences:共享参数形式,一种以Key-Value的键值对...
  • Android中数据存储的持久化技术有:文件存储,SharePreference存储,数据库存储,或者将数据存储在SD卡中,存储在SD卡上有一定的不安全因素。 1。文件存储 文件存储是Android中最基本的存储方式,它在存储的过程...
  • 原文: ...Android系统为我们提供了五种数据持久化存储方式,以满足不同的需求。 他们分别是: Shared Preferences Store private primitive data in key-valu
  • 1.数据持久化存储 android提供了4种文件存储方式:文件(/data/data/<包名>/files/),SharePreference(/data/data/<包名>/shared prefs/) , SQLite数据库(/data/data/<包名>/database/)和...
  • Android数据持久化存储共有四种方式,分别是文件存储、SharedPreferences、Sqlite数据库和ContentProvider。在本篇幅中只介绍前面三种存储方式,因为ContentProvider属于android四大组件之一,所以它的数据存储方式...
  • Android系统主要提供了3中方式用于简单地实现数据持久化的功能,其中包括文件存储,SharedPreference存储以及数据库存储。这里来看下如何通过文件存储方式持久化数据。  首先来看看数据是如何存储到文件中的,...
  • Android系统中主要提供了3种方式用于简单地实现数据持久化功能,文件存储SharedPreferences存储数据库存储1.文件存储Context类中提供了一个openFileOutput()方法,可以用于将数据存储到指定的文件中。这个方法接收两...
  • SharedPreferences使用键值对的方式存储数据 存储一个数据的时候,需要给这个数据提供一个键,取这个数据的时候也需要使用这个键来取. * SharedPreferences对象的获取方式 * 1.Context类中的...
  • Android存储数据回顾笔记Sqlite数据库 存储位置: data/data/包名/databases/数据库 通过继承SQLiteOpenHelper创建数据库和表 onCreate():当数据第一次创建的时候调用创建数据库 onUpgrade():更新数据库的...
  • 在讨论数据持久化技术之前我们先了解几个概念? 什么是瞬时数据:存储在内存当中,有可能会因为程序的关闭或其他原因导致内存被收回而丢失的数据...安卓提供了三种方式用于简单的数据持久化功能:文件储存,SharedP...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 498
精华内容 199
关键字:

android持久化存储方式