精华内容
下载资源
问答
  • 安卓数据存储方式

    千次阅读 2013-06-29 23:19:11
    安卓数据存储--三种基本方式 1 通过SharedPreferences存储 SharedPreferences:负责读取程序的Preferences数据 保存的是MAP类型,存储简单地数据 步骤: getSharedePreferences(String name,int MODE); 存储: ...
    Log.i() 

    安卓数据存储--三种基本方式
    1  通过SharedPreferences存储
    SharedPreferences:负责读取程序的Preferences数据
    保存的是MAP类型,存储简单地数据
    步骤:
    getSharedePreferences(String name,int MODE);
    存储:
    SharedPreferences setttings =getSharePreferences(SETTING_INFOS,0)
    setttings.edit()
    .putString(NAME,text1.getText().toString())
    .putString(PASSWORD,text2.getText().String())
    .commit();
    提取:
    SharedPreferences settings=getSharedPreferences (SETTING_INFOS,0)
    String name=settings.getString(NAME,"");
    String passwd=settings.getString(PASSWORD,"");
    text1.setText(name);
    text2.setText(passwd);
    *********************************************************************************
    *********************************************************************************


    2 文件存储
    FileInputStream和FileOutPutStream
    Context提供了两个方法:


    openFileInput(String fileName):打开文件对应的输入流
    openFileOutput(String fileName,int mode):打开对应的输出流
    还有其他方法访问文件夹:
    getDir(String name,int MODE);
    getFilesDir();
    deleteFile(String name);


    mode:
    MODE_PRIVATE:当前程序可用
    MODE_APPEND: 追加模式写入
    MODE_WORLD_READABLE:其他程序可读
    MODE_WORLD_WRITEBLE:其他程序可写


    示例:
    public FileTest extends Activity{
    @Override 
    public void onCreate(Bundle savedInsatnceState)
    {
    super.onCreate(savedInstancestate);
    setCotentView(R.layout.main);
    BUtton read=(Button)findViewById(R.id.read);
    Button write=(Button)findViewById(R.id.write);
    final EditText edit1=(EditText)findViewById(R.id.edit1);
    final EditText edit2=(EditText)findViewById(R.id.edit2);
    write.setOnClickListener(new OnClickListener(){
    @Override
    public void onClick(View v){
    write(edit.getText.toString());
    edit1.setText("");
    }
    });
    read.setOnClickListener(new OnCilckListener{
    public void onClick(View v){
    edit2.setText(read());
    }
    });
    }
    private String read(){
    try{
    FileInPutStream fis=openFileInput(FILE_NAME);
    byte[] buff=new byte[1024];
    int hasrad=0;
    StringBuilder sb=new SreingBuilder("");
    while((hasread=fis.read(buff))>0){
    sb.append(new String(buff,0,hasread));
    }
    return sb.toString();


    }
    }
    private void write(String content){
    try{
    FileOutPutStream fos=openFileOutput(FILE_NAME,MODE_APPEND);
    printSream  ps=new printStream(fos);
    pa.println(content);
    ps.close();
    }catch(Exception e){e.printStackTrace();}
    }
    }
    ******************************************************************************
    ******************************************************************************




    3 数据库存储
    SQLite数据库:
    SQLiteDatabase:


    android自带的一个数据路,底层是一个数据库文件。作用类似于JDBC(java databse connectivity)的Connnection接口
    既可以使用sql语句操作管理数据库,也可以使用对象示例中定义的一些方法:


    创建数据路对象:
    static SQLiteDatabase openOrCreateDatabase(String path,SQLiteDatabase.CursorFactory factory);
    static SQLiteDatabase openDatabase(String path,SQLiteDatabase.CursorFactory factory,int flags);


    操作数据库:
    //使用sql语句
    execSQL(String sql);
    execSQL(String sql,Obeject[] bindArgs);
    //返回一个Cursor对象
    //使用方法
    insert,update,delete,query,rawquery
    查询方法都返回指针类-Cursor
    该类的对象有几个移动指针的函数:
    move(int offset); //移动到指定行
    boolean moveToFirst(); //
    boolean moveToLast(); //
    boolean moveToNext(); //移动到下一行
    boolean moveToPrevious();
    boolean moveToposition(int position);






    SQLiteOpenHelper:
    用于管理数据库的工具类
    常用方法:
    SQliteDatabase getReadableDatabase();
    SQliteDatabase et writableDatabese();
    onCreate();
    onUpdate();
    close();
    示例:
    public class MyDatabaseHelper extends SQLiteDatabaseHelper
    {
    final String CREATE_TABLE_SQL="create table dict(_id integer primary key antoincrement,word,detail)";
    public MyDatabaseHelper(Context context,String name,int version){
    super(context,name,null,version);
    db.execSQL("insert into dict values(null,?,?)",new String[]{word,detail});
    }
    @Override


    }
    //定义一个继承了DatabseHelper类的MyDatabseHelper类
    //第一次调用getW/RDatabse是自动调用onCreate方法,所以重写了onCreate方法
    public Dict extends Activity
    {
    MyDatabaseHelper dbHelper;
    Button inseart=null;
    Button search=null;
    public void onCreate(Bundle savedInsatnceState){
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    dbHelpre=new MyDatabaseHelper(this,"myDict.db",1);
    insert=(BUtton)findVIewById(R.id.insert);
    serach=(Button)findVeiwById(R.id.serach);
    insert.setOnClickLisener(new OnClickListener(){
    @Override
    public void onClick(View source){
    String word=((EditView)findViewById(R.id.wrod)).getText().toString();
    String detail=((EditVIew)findViewById(R.id.detail))getText.toString();
    insertData(dbHelper.getReadableDatabase(),word,detail);
    Toast.makeText(Dict.this,"添加成功",Toast.SHORT).show();
    }
    });
    serach.setOnClickLisetner(new OnCLickListener(){
    @Override
    public void onClick(View v){
    String key=(EditView)findViewById(R.id.key).getText().toString();
    Cursor cursor=dbHelper.getReadableDatabase().rawQuery("select * from dict where word like ? or detail like ?",new String[]{"%"+key+"%","key"+key"%"});
    Bundle bundle=new Bundle();
    data.putSerializable("data",converCursorToList(cursor)); //data为键值
    Intent intent=new Intent(Dict.this,ResultActivity.class);
    intent.putExtras(data);
    startActivity(intent);
    }
    });
    }
    protected ArrayList<Map<String,String>> coverCursorToList(Cursor cursor){
    ArrayList<Map<String,String>>result=new ArrayList<Mop<String,String>>();
    while(cursor.moveToNext()){
    Map<String,String>map=new HashMap<String,String>();
    map.put("word",cursor.getString());
    map.put("detail",cursor.getString());
    }
    return result;
    }
    private void insertData(SQLiteDatabase db,String word,String detail){
    db.execSQL("insert into dict values(null,?,?),new String[](word,detail);")
    }
    @Override
    public void onDestroy{
    super.onDestroy();
    if(dbHelper!=null){dbHelper.close();}
    }
    }
    //ResultActivty
    pubic class extends Activity
    {
    @Override
    public void onCreate(Bundle InstanceState){
    super.onCreate(Bundle InstanceState);
    setContentView(R.layout.popup);
    LisView list=(ListView)findVIewById(R.id.show);
    Bundle data=new BUndle();
    data=intent.getExtras();
    List<Map<String,String>>list=(List<Map<String,String>>)dara.getSerializable("data");
    SimpleAdapter adapter=new SimpleAdapter(ResultActivity,list,R.layout.line,new String[]{"word","detail"},new int[]{R.id.word,R.id.detail});
    list.setAdapter(adapter);
    }
    }
    展开全文
  • 安卓中的数据存储

    2015-11-21 13:51:08
    4.网络访问 Network,分为socket,http,https由于本人也在学习阶段,写此博客也是为了日后复习方便,所以今天我只介绍share preference这种最为简单的存储方式,日后再为大家介绍其余的三种方式。share prefere

    安卓中的数据存储:
    1.xml(share preference)
    2.Bianray File(file)
    3.关系型数据库 SQLite3
    4.网络访问 Network,分为socket,http,https

    由于本人也在学习阶段,写此博客也是为了日后复习方便,所以今天我只介绍share preference这种最为简单的存储方式,日后再为大家介绍其余的三种方式。

    share preference的使用方式是get shaeredpreferences(),get preferences();

    Call edit() to get a SharedPreferences Editor
    Add values with methods such as putBoolean() and putString()
    Comint the new values with commit

    这里面简单的涉及到了一点键值对的知识,即key,value;

    官方给我用的代码为:

    这里写图片描述

    然后为了让大家更好的理解,我给大家举了一个 非常好理解的例子,就是让系统自动保存我们的用户名,然后我们可以在ddms里面的data文件夹里面找到我们保存的内容,是以.xml的形式进行存储的。

    public class MainActivity extends AppCompatActivity {
        SharedPreferences mSharedPreferences;
        private EditText editText1;
        private CheckBox checkBox1;
        private SharedPreferences.Editor editor;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            initviews();
        }
    
        public void initviews() {
            //得到对象
            editText1 = (EditText) findViewById(R.id.editText);
            checkBox1 = (CheckBox) findViewById(R.id.bt_wifi);
            //第一种方法:
            // mSharedPreferences = getSharedPreferences("sundy", MODE_PRIVATE);
    
            //第二种方法:
    
            mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
    
    
    //        if (mSharedPreferences!=null){
    //
    //            mSharedPreferences.getBoolean("wifi_toggle",false);
    //            checkBox1.setChecked(mSharedPreferences.getBoolean("wifi_toogle", false));
    //            editText1.setText(mSharedPreferences.getString("your_name",""));
    //        }else{
    //            Toast.makeText(MainActivity.this, "--8888", Toast.LENGTH_SHORT).show();
    //            Log.i("sys","--sir---no xml");
    //
    //        }
    
    
            Button button1 = (Button) findViewById(R.id.button);
            button1.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
    
                    //编辑(并不是真正的编辑 打开对象)
                    editor = mSharedPreferences.edit();
    
                    editor.putBoolean("wifi_toggle", checkBox1.isChecked());
    
    
                    editor.putString("your_name", editText1.getText().toString());
    
                    //真正的提交事务
                    editor.commit();
    
                    Toast.makeText(MainActivity.this, "修改保存", Toast.LENGTH_SHORT).show();
                }
            });
    
    
        }
    }
    

    这样写完了之后呢,我们便可以在关掉我们的程序之后,再次开启的时候看到我们上次写的内容。
    以上便是我对于第一种方式的简单的整理,之后我还会为大家讲解其余的方式。

    展开全文
  • RT,今天要写的是安卓种数据存储方式。 一,首先我想到的就是创建本地数据库,前段时间刚用了一个叫GreenDao的第方,他的用法很简单,这里我直接贴上操作步骤和代码,网上很多教程(我也是跟着教程来,然后再...

    这是我的第一篇博客,前言也不多说什么,有点小激动,还是直接进入正题吧。

    RT,今天要写的是安卓几种数据存储的方式。

    一,首先我想到的就是创建本地数据库,前段时间刚用了一个叫GreenDao的第三方,他的用法很简单,这里我直接贴上操作步骤和代码,网上很多教程(我也是跟着教程来,然后再自己加以琢磨)。

    (下面这个是基本配置网上抄的)

    一. 在 ANDROID 工程中配置「GREENDAO GENERATOR」模块

    1. 在 .src/main 目录下新建一个与 java 同层级的「java-gen」目录,用于存放由 greenDAO 生成的 Bean、DAO、DaoMaster、DaoSession 等类。 

    2. 配置 Android 工程(app)的 build.gradle,如图分别添加 sourceSets 与dependencies。 

    1
    2
    3
    4
    5
    sourceSets {
            main {
                java.srcDirs = ['src/main/java''src/main/java-gen']
            }
        }
    1
    compile 'de.greenrobot:greendao:2.1.0'(这里注意下版本要高) 


    二. 新建「GREENDAO GENERATOR」模块 (纯 JAVA 工程)

    1. 通过 File -> New -> New Module -> Java Library -> 填写相应的包名与类名 -> Finish.

    2. 在另外的模块里面的gradle配置 daoexamplegenerator 工程的 build.gradle,添加 dependencies.

    3.  

    1
    compile 'de.greenrobot:greendao-generator:1.3.1'
    1. 编写 ExampleDaoGenerator 类,注意: 我们的 Java 工程只有一个类,它的内容决定了「GreenDao Generator」的输出,你可以在这个类中通过对象、关系等创建数据库结构,下面我将以注释的形式详细讲解代码内容。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    public class ExampleDaoGenerator {
        public static void main(String[] args) throws Exception {
            // 正如你所见的,你创建了一个用于添加实体(Entity)的模式(Schema)对象。
            // 两个参数分别代表:数据库版本号与自动生成代码的包路径。
            Schema schema = new Schema(1, "me.itangqi.greendao");//版本号,生成代码的包路径
    //      当然,如果你愿意,你也可以分别指定生成的 Bean 与 DAO 类所在的目录,只要如下所示:
    //      Schema schema = new Schema(1, "me.itangqi.bean");
    //      schema.setDefaultJavaPackageDao("me.itangqi.dao");
     
            // 模式(Schema)同时也拥有两个默认的 flags,分别用来标示 entity 是否是 activie 以及是否使用 keep sections。
            // schema2.enableActiveEntitiesByDefault();
            // schema2.enableKeepSectionsByDefault();
     
            // 一旦你拥有了一个 Schema 对象后,你便可以使用它添加实体(Entities)了。
            addNote(schema);
     
            // 最后我们将使用 DAOGenerator 类的 generateAll() 方法自动生成代码,此处你需要根据自己的情况更改输出目录(既之前创建的 java-gen)。
            // 其实,输出目录的路径可以在 build.gradle 中设置,有兴趣的朋友可以自行搜索,这里就不再详解。
            new DaoGenerator().generateAll(schema, "/Users/tangqi/android-dev/AndroidStudioProjects/MyGreenDAO/app/src/main/java-gen");//这句必须要
        }
     
        /**
         * @param schema
         */
        private static void addNote(Schema schema) {
            // 一个实体(类)就关联到数据库中的一张表,此处表名为「Note」(既类名)
            Entity note = schema.addEntity("Note");//创建关联实体类的表,输入类的名字
            // 你也可以重新给表命名
            // note.setTableName("NODE");
     
            // greenDAO 会自动根据实体类的属性值来创建表字段,并赋予默认值
            // 接下来你便可以设置表中的字段:
            note.addIdProperty();//开始设置字段了
            note.addStringProperty("text").notNull();
            // 与在 Java 中使用驼峰命名法不同,默认数据库中的命名是使用大写和下划线来分割单词的。
            // For example, a property called “creationDate” will become a database column “CREATION_DATE”.
            note.addStringProperty("comment");
            note.addDateProperty("date");
        }
    }

    三. 生成 DAO 文件(数据库)

    • 执行 generator 工程,如一切正常,你将会在控制台看到如下日志,并且在主工程「java-gen」下会发现生成了DaoMaster、DaoSession、NoteDao、Note共4个类文件。 

    • 然后在studio右键点击 run```的 他就会出来一串write之类的东西主要看看是否有结果生成  不为0就好如我的   Processed 3 entities in 1010ms

    如果在此处出错,你可以依据错误日志进行排查,主要看是否输出目录存在?其他配置是否正确?等

    四. 在 ANDROID 工程中进行数据库操作

    接下来的操作是在db(我喜欢这么命名)文件下新建一个openhelper类,里面有实力化的方法和一些增删改查的方法

    举个例子(下面的内容和上面ExampleDaoGenerator类无关·····

    //实例化
    public Anamial(Context context) {
        alarmBeanList=new ArrayList<>();
        try{
            alarmBean= GetDaoSession.getDaoSession(context,"alarm.db").getAlarmBeanDao();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public static  AlarmDaoHelper getInstance(Context context){
        if (alarmDaoHelper==null){
            synchronized (AlarmDaoHelper.class){
                if (alarmDaoHelper==null){
                    alarmDaoHelper=new AlarmDaoHelper(context);
                }
            }
        }return alarmDaoHelper;
    }
    /*********增加数据*********/
    @Override
    public <T> void addDada(T data) {
    if (alarmBean!=null&&data!=null){
        alarmBean.insertOrReplace((AlarmBean) data);
    
        }
    }
    /****删除数据****/

    @Override
    public void deleteData(Long id) {//这个id是要在你的生成的那个类里面的
        if (alarmBean!=null&&id!=null){
            alarmBean.deleteByKey(id);
    
        }
    //查询
    /**
     * get alarms by startdate
     *
     * @param startDate
     * @return
     */
    public List<AlarmBean> getAlarmsByStartDate(String startDate) {
        if (startDate != null) {
            Query query = alarmBean.queryBuilder()
                    .where(AlarmBeanDao.Properties.StartDate.eq(startDate))
                    .orderAsc(AlarmBeanDao.Properties.RelshowTime)//插入的意思
                    .build();
    
            List<AlarmBean> notes = query.list();
            QueryBuilder.LOG_SQL = true;
            QueryBuilder.LOG_VALUES = true;
            return notes;
        }
        return emptyList;
    }
    //更新数据的话建议根据条件查询到数据之后,获得他对应的ID 在通过ID把原来的删除掉,再添加一条数据,这样就更新好了。


    二,要讲的是偏好设置sharedPreferences

    可以用来保存用户的一些简单的使用习惯信息,偏好设置实质上是/data/data/包/share_prefs/路径下的一个xml文件,文件名就是偏好设置的名字。

    如何使用ShardPreference将数据持久化:

    通过getSharedPreferences(String name,int mode)来获取一个SharedPreferences对象,一个应用可以有多个偏好设置文件,第一个参数决定用哪个,第二个参数表示模式,一般用MODE_PRIVATE,只能本应用来读(全局可读、全局可写这些模式不建议使用)

    保存: 调用SharedPreferences对象的edit()方法,开始修改它,这个方法会返回一个Editor对象,我们调用这个对象的putXXX方法往里面放简单的信息,在写好后再调用commit()方法来确认

    Activity中存入数据

    //获取一个私有的偏好设置,名字为demo

    SharedPreferences pref = getSharedPreferences("demo"MODE_PRIVATE);

    //获取一个编辑器,开始对这个偏好设置进行读写操作

    Editor editor = pref.edit();

    //往编辑器里存放键值对信息

    editor.putString("info""w");

    editor.putInt("num", 1000);

    //确认,使上述信息生效

    editor.commit();//东西一多的话用apply提交(另外开一个线程提交,异步操作,而commit有结果,apply没有结果)

    Activity中获取数据

    获取: 调用SharedPreferences对象的getXXX方法根据键获取值

    SharedPreferences pref = getSharedPreferences("demo"MODE_PRIVATE);

    //直接通过偏好设置对象获取存在其中的信息,通过键获取值

    //第一个参数就是键名,第一个是默认值(没有存的情况下起作用)

    String info = pref.getString("info""信息还未存入");

    int number = pref.getInt("num", 0);//是什么数据类型就get什么类型

    三.存到应用程序的Data File目录

    在内置存储器中,在应用程序目录中,可以保存稍微大些的文件信息,在应用程序被删除时,这个目录及内部的所有内容也会连带删除(在/data/data/包名/files目录下)

    写文件示例:

    public void save()
     {
     
            try {
                FileOutputStream outStream=this.openFileOutput("a.txt",Context.MODE_WORLD_READABLE);//openFileOutput(): 获取一个字节输出流,向内置文件写
                outStream.write(text.getText().toString().getBytes());
                outStream.close();//关闭流
            } catch (FileNotFoundException e) {
                return;
            }
            catch (IOException e){
                return ;
            }
     
     } 
    openFileOutput()方法的第一参数用于指定文件名称,不能包含路径分隔符“/” ,如果文件不存在,Android 会自动创建它。
    创建的文件保存在/data/data//files目录,如: /data/data/cn.itcast.action/files/itcast.txt ,
    读取文件示例:
    public void load()
    {
        try {
            FileInputStream inStream=this.openFileInput("a.txt");//openFileInput(): 方法获取一个字节输入流,用来读
            ByteArrayOutputStream stream=new ByteArrayOutputStream();
            byte[] buffer=new byte[1024];
            int length=-1;
    while((length=inStream.read(buffer))!=-1)   {
                stream.write(buffer,0,length);
            }
     
            stream.close();
            inStream.close();
            text.setText(stream.toString());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        catch (IOException e){
            return ;
        }
     
    }  
    对于私有文件只能被创建该文件的应用访问,如果希望文件能被其他应用读和写,可以在创建文件时,指定Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE权限。(权限记得加上不然很蛋疼)

    四.存到应用程序的Data cache目录缓存

    在内置存储器中,在应用程序目录中,也可以保存大文件,和File目录的区别是,在存储空间吃紧的情况下,这个目录下的内容可能被自动删除(在/data/data/包名/cache目录下)

    File.getCacheDir():获取代表缓存路径的文件对象,然后可以在这个路径下new文件对象,再使用输入流、输出流对文件进行处理

    Activity还提供了getCacheDir()和getFilesDir()方法: getCacheDir()方法用于获取/data/data//cache目录 getFilesDir()方法用于获取/data/data//files目录。

    五.sdcard 外存

    Sd卡,外置存储器中可以保存更大一些的文件,在应用程序删除时数据可以保留下来

    1. 首先,要访问外部存储设备,必须要声明write_external_storage 权限。
    2. 在代码中,要对外存操作,先要判断sd卡是否已挂载。用Environment的静态方法getExternalStorageState()方法获取外存的状态,如果是mounted的话说明已经挂载,如果是removed则没有挂载

    3、使用EnvirogetExternalStorageDirectory方法获取sd卡根路径的File对象,再用getPath获取其路径字符串。sd卡根目录是/storage/sdcard

    在getExternalStoragePublicDirectory方法中传入DIRECTORY_PICTURES,就返回这个android系统在外存中存储图片的公共目录,在这里是/storage/sdcard/Pictures

    在getExternalStoragePublicDirectory方法中传入DIRECTORY_DOWNLOADS,,就返回这个系统在外存中存放下载的文件的公共目录,在这里是/storage/sdcard/Downloads

    ......

    注意:有些手机的文件路径是定制的,所以尽量要使用api去获取路径,而不要将路径写死,避免硬件厂商定制路径造成的bug

    除了sd卡中的公有目录,还可以在我们程序自己定的私有目录下读写文件。在sd卡根目录上创建我们自己的目录file.mkdirs(),并在其中创建文件进行读写

     

    另外:为了避免sd卡空间不足造成损失,我们可以预先判断sd卡空间,使用StatFs类,先创建一个statFs对象,再用其中的一些方法进行判断。

    StatFs stat = new StatFs(Environment.getExternalStorageDirectory().getPath());

    int availableBlocks = stat.getAvailableBlocks();//获取sd卡中可用的块数

    int blockCount = stat.getBlockCount();//获取sd卡中块的总数

    int blockSize = stat.getBlockSize();//获取每个块的字节数

    可用块数*每块字节数=可用字节数;总块数*每块字节数=总字节数

    注意:不要用getFreeBlocks(),这个是空闲块数,空闲不一定可用

    六.将数据保存在服务器端

    通过post传参方式,将文件上传到服务器端(云端)

    try {

        HttpURLConnection con = (HttpURLConnection) new URL("http://10.31.151.216:8080/up/upload").openConnection();

        con.setDoOutput(true);

        con.setRequestMethod("POST");

        con.setRequestProperty("Content-Type", "multipart/form-data;"+ " boundary=1234");

        con.connect();

        OutputStream os = con.getOutputStream();

        os.write("1234\r\n".getBytes());

        os.write("Content-Disposition: form-data; name=\"file1\"; filename=\"android.png\"\r\n".getBytes());

        os.write("\r\n".getBytes());

        FileInputStream fis = new FileInputStream("e:/android.png");

        int n= 0;

        byte[] buffer = new byte[1024];

        while((n = fis.read(buffer)) != -1){

            os.write(buffer, 0, n);

        }

        fis.close();

        os.write("\r\n\r\n".getBytes());

        os.write("123455\r\n".getBytes());

        System.out.println("read");

        BufferedReader br = new BufferedReader(new InputStreamReader(con.getInputStream()));

        String line =  null;

        while((line = br.readLine())!=null){

            System.out.println(line);

        }

    } catch (MalformedURLException e) {

        e.printStackTrace();

    } catch (IOException e) {

        e.printStackTrace();

    }


    好了,以上是我总结的几种数据存储的方式,后面几种写得比较简单,以后慢慢补齐吧。

    展开全文
  • 1、回顾之前学习的三种数据存储方式(SharedPreferences、xml和Sqlite) 2、文件存储(存储数据到data/data/packagename/files和存储数据到sdcard) 1、回顾之前学习的三种数据存储方式(SharedPreferences、xml...

    存储数据(下)——文件存储

    这篇文章学到的内容:
    1、回顾之前学习的三种数据存储方式(SharedPreferences、xml和Sqlite)
    2、文件存储(存储数据到data/data/packagename/files和存储数据到sdcard)
    

    1、回顾之前学习的三种数据存储方式(SharedPreferences、xml和Sqlite)

    SharedPreferences

    轻量级的存储类,主要保存一些常用的配置,适合用简单的数据类型,int、String、boolean等。它的本质也是基于xml来存储key-value键值对数据。

    Xml存储

    轻量级的存储类,如果数据量不大,但是数据又比较复杂,可以选择使用这种方式存储数据。可以自定义xml标签格式。处理xml时,能通过自带底层的本地xml Parser来解析xml。这里建议采用xmlpull方式来操作xml

    Sqlite存储

    功能强大,可以实现数据库的许多操作。它就是一个轻量级的数据库,被设计用于嵌入式的设备,所以android采用sqlite来作为支持的关系型数据库管理系统。到2015年,sqlite已经到sqlite3了,具体的操作,和我们常见的数据库一样。如果数据量大,而且有许多关系表,建议采用数据库来做数据存储。

    2、进入主题,介绍文件存储方式

    android除了上面的三种方式,还有三种数据存储:文件存储、contentProvider存储,网络存储。这里介绍文件存储。后两个以后会讲。

    3、文件存储

    文件存储的方式,说白了就是通过流的方式来创建文件来存储数据。只不过,我们是在手机的存储卡中来创建这些文件的。

    存储数据到data/data/packagename/files

    关键代码就是Context.openFileOutput(fileName, mode);执行这句话,会在data/data/packagename/files目录下创建fileName文件,我们可以用流的方式把数据写入到fileName中。mode是文件模式。你可也在后面的文件模式查看android支持的缓存文件模式。

    存内容

    这里只贴关键代码。

     1     /**
     2      * 存储内容到data/data/packagename/file
     3      * 
     4      * @param act
     5      * @param content
     6      *            文件内容
     7      * @param fileName
     8      *            文件名
     9      * @param mode
    10      *            模式
    11      */
    12     public static void saveContentToDataFile(Activity act, String content,
    13             String fileName, int mode) {
    14 
    15         try {
    16             FileOutputStream fos = act.openFileOutput(fileName, mode);
    17             fos.write(content.getBytes("UTF-8"));
    18             fos.close();
    19         } catch (Exception e) {
    20             e.printStackTrace();
    21         }
    22     }

     

    读内容

    这里只贴关键代码。

     1     /**
     2      * 读取data/data/packagename/file/fileName文件中的字符内容
     3      * @param act
     4      * @param fileName
     5      * @return
     6      */
     7     public static String readContentFromDataFile(Activity act, String fileName) {
     8 
     9         String result = "";
    10         try {
    11             FileInputStream in = null;
    12             ByteArrayOutputStream bout = null;
    13             byte[] buf = new byte[1024];
    14             bout = new ByteArrayOutputStream();
    15             int length = 0;
    16             in = act.openFileInput(fileName); // 获得输入流
    17             while ((length = in.read(buf)) != -1) {
    18                 bout.write(buf, 0, length);
    19             }
    20             byte[] content = bout.toByteArray();
    21             result = new String(content, "UTF-8"); 
    22             in.close();
    23             bout.close();
    24         } catch (Exception e) {
    25             e.printStackTrace();
    26         }
    27         return result;
    28     }

     

    检查文件是否存在

    这里只贴关键代码。

     1     /**
     2      * 检查file是否存在
     3      * @param act
     4      * @param fileName
     5      * @return
     6      */
     7     public static boolean checkFileIsExistInData(Activity act, String fileName){
     8         
     9         boolean result = false;
    10         File file = act.getFileStreamPath(fileName);
    11         if (file != null && file.exists()) {
    12             result = true;
    13         }
    14         return result;
    15     }

     

    文件模式

    1.Context.MODE_PRIVATE:私有覆盖模式

    只能被当前应用访问,并且如果写入,则覆盖。

    2.Context.MODE_APPEND:私有追加模式

    只能被当前应用访问,并且如果写入,则追加。

    3.Context,MODE_WORLD_READABLE:公有只读模式

    可以被其他应用读取。

    4.Context.MODE_WORLD_WRITEABLE:公有可写模式

    可以被其他应用写入,但不能读取。 注意,如果希望其他使得文件模式叠加,则可以使用加号连接:
    比如:Context.MODE_WORLD_READABLE+Context.MODE_WORLD_WRITEABLE表示其他应用可读写。

    存储文件到SDCard

    关键代码,就是要获得sdcard的根路径。Environment.getExternalStorageDirectory()就是得到当前外部存储设备的根目录。

    检测sdcard设备是否存在

    这里只贴关键代码。

     1     public static boolean checkSDCARD() {
     2 
     3         String status = Environment.getExternalStorageState();
     4 
     5         if (status.equals(Environment.MEDIA_MOUNTED)) {
     6             return true;
     7         }
     8 
     9         return false;
    10     }

     

    在sdcard中创建目录

    这里只贴关键代码。

     1     public static boolean createDir2SDCard(String path) {
     2 
     3         File dir = new File(path);
     4 
     5         if (!dir.exists()) {
     6             return dir.mkdirs();
     7         }
     8 
     9         return true;
    10     }

     

    在sdcard中创建文件

    这里只贴关键代码。

     1     public static File createFile2SDCard(String path, String fileName) {
     2 
     3         // ///
     4         // 创建SD卡目录
     5         // ///
     6         File dir = new File(path);
     7 
     8         if (!dir.exists()) {
     9             dir.mkdirs();
    10         }
    11 
    12         // //
    13         // 创建SD卡文件
    14         // ///
    15         File file = new File(path + fileName);
    16 
    17         if (file.exists()) {
    18 
    19             file.delete();
    20         }
    21 
    22         try {
    23             file.createNewFile();
    24         } catch (IOException e) {
    25             // TODO Auto-generated catch block
    26             e.printStackTrace();
    27         }
    28 
    29         return file;
    30     }

     

    在sdcard中删除目录和目录下的所有文件

    这里只贴关键代码。

        public static boolean deleteDir4SDCard(String path) {
    
            File dir = new File(path);
    
            if (dir.exists()) {
                File[] files = dir.listFiles();
    
                for (File file : files) {
    
                    file.delete();
                }
    
                dir.delete();
            }
    
            return true;
        }

     

    在sdcard中检查文件是否存在

    这里只贴关键代码。

     1     public static boolean checkFileExist(String path) {
     2 
     3         File file = new File(path);
     4 
     5         if (file.exists()) {
     6 
     7             return true;
     8         }
     9 
    10         return false;
    11     }

     

    在sdcard中创建文件并写入内容

    这里只贴关键代码。

     1     /**
     2      * 保存内容到sdcard
     3      * @param act
     4      * @param content
     5      * @param fileName
     6      * @param mode
     7      */
     8     public static void saveContentToSDCardFile(Activity act, String content,
     9             String fileName) {
    10 
    11         if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { // 如果sdcard插入
    12             try {
    13                 String sdcardRootPath = Environment.getExternalStorageDirectory() + "/";
    14                 FileOutputStream fos = new FileOutputStream(sdcardRootPath + fileName); 
    15                 fos.write(content.getBytes("UTF-8"));
    16                 fos.close();
    17             } catch (Exception e) {
    18                 e.printStackTrace();
    19             }
    20         }
    21     }

     

    在sdcard中读取内容

    这里只贴关键代码。

     1     /**
     2      * 从sdcard中某个文件读取内容
     3      * @param act
     4      * @param fileName
     5      * @return
     6      */
     7     public static String readContentFromSDCardFile(Activity act, String fileName) {
     8 
     9         String result = "";
    10         if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { // 如果sdcard插入
    11             String sdcardRootPath = Environment.getExternalStorageDirectory() + "/";
    12             try {
    13                 FileInputStream in = null;
    14                 ByteArrayOutputStream bout = null;
    15                 byte[] buf = new byte[1024];
    16                 bout = new ByteArrayOutputStream();
    17                 int length = 0;
    18                 in = new FileInputStream(sdcardRootPath + fileName); 
    19                 while ((length = in.read(buf)) != -1) {
    20                     bout.write(buf, 0, length);
    21                 }
    22                 byte[] content = bout.toByteArray();
    23                 result = new String(content, "UTF-8"); 
    24                 in.close();
    25                 bout.close();
    26             } catch (Exception e) {
    27                 e.printStackTrace();
    28             }
    29         }
    30         return result;
    31     }

     

     

    本站文章为 宝宝巴士 SD.Team 原创,转载务必在明显处注明:(作者官方网站: 宝宝巴士 
    转载自【宝宝巴士SuperDo团队】 原文链接: http://www.cnblogs.com/superdo/p/4809580.html

     

    转载于:https://www.cnblogs.com/superdo/p/4809580.html

    展开全文
  • 1)文件存储是Android中最基本的一种数据存储方式,它不对存储的内容进行任何的格式化处理,所有数据都是原封不动地保存到文件当中的,因而它比较适合用于存储一些简单的文本数据或二进制数据。 2)Context类中提供...
  • Android系统中主要提供了三种方式用于简单的实现数据持久化功能: 文件存储(手机自带的内存)、SharedPreferences存储以及数据库存储 当然还可以用sd卡存储 读入写出 下面是疯狂java讲义中的关于IO流的一些补充,回忆...
  • 在讨论数据持久化技术之前我们先了解几个概念? 什么是瞬时数据存储在内存当中,有可能会因为程序的关闭或其他原因导致内存被收回而丢失的数据...安卓提供了三种方式用于简单的数据持久化功能:文件储存,SharedP...
  • 数据存储

    2017-09-16 01:45:00
    1.持久化技术简介 瞬间数据指的是存储在内存当中的数据,有可能因为程序关闭或其他原因导致内存被回收而丢失的数据。所以为了解决这个缺点,就出现了数据...而安卓系统主要提供了三种方式来实现数据持久化功能,为...
  • 上一篇讲了文件存储path_provider的使用,今天接着学习第三种数据存储方式:Sqlite3。在Flutter中的数据库叫Sqflite跟原生安卓的Sqlite叫法不一样。我们来看下Sqflite官方对它的解释说明: SQLite plugin for ...
  • 1.键值对方式存储。 2.Android6.0之后只有一...3.三种得到SharedPreferences对象 4.SharedPreference存储数据 eg: SharedPreferences.Editor editor=getSharedPreferences("File_name",MODE_PRIVATE).edit(); editor.p
  • 安卓里面,获取数据方式有两种,第一种就是我们之前所讲的网络获取,第二种就是我们接下来要讲的本地获取数据,本地获取的方式有通过文件获取,SharedPreferences(简称sp),sqlite数据库获取 三种方法 ...
  • /我挥舞着键盘和本子,发誓要把世界写个明明白白/安卓提供了三种数据持久化技术,分别为:文件存储、SharedPreference、数据库存储。二、SharedPreferences 1)不同于文件的存储方式,SharedPreferences是使用键值...
  • 安卓提供了三种方式用于简单的数据持久化功能:文件储存,SharedPreference存储,数据库储存。 6.2 文件存储 用于保存一些简单的文本数据或二进制数据。  使用到的方法:Context类中提供了ope
  • 安卓提供的一种轻量级的数据库(不需安装的内置数据库),是一种数据存储方式之一,一般用于数据量大,数据结构复杂的情况下 二、三种常用数据类型 text 文本型/字符型 integer 整型,自增长,主键 real ...
  • 安卓实战开发之SQLite从简单使用crud

    千次阅读 2016-06-19 15:59:17
    最近项目忙,然后呢很久没有更新博客了,react-native也是没有时间学习,然后项目里面用到了数据持久化(数据存储),Android系统中主要提供了三种数据持久化方式:文件存储、SharedPreference存储、数据库存储。...
  • Content Provider ...之前介绍了安卓中几持久化的方式,应用中的数据可以被“永久性”的存储下来,但是大多数情况下,这些数据只能被它的持有者所访问,其他应用程序无法访问和获取,那么有没有办法去实...
  • 安卓存储数据—文件储存(模拟备忘录) 今天来说说安卓存储数据三种方式特点
  • 首先介绍数据持久化:指将那些内存中的瞬时数据保存到存储设备中,保证即使在手机或电脑关机的情况下,这些数据仍然不会丢失。...还有一种不安全的存储方式–文件存在手机的sd卡中,它不如前三种方式操
  • 黑马安卓52期视频教程

    热门讨论 2015-06-24 22:15:48
    day02_Android应用开发-数据存储和界面展现 00_剧情回顾 01_线性布局 02_相对布局 03_帧布局 04_表格布局 05_绝对布局 06_logcat输出 07_在内部存储中写文件 08_在内部存储中读文件 09_使用路径API获取内部存储的...
  • 数据持久化技术

    2015-11-22 00:14:00
    数据储存方案,持久化即技术 什么是瞬时数据存储在内存当中,有可能会因为程序的关闭或其他原因导致内存被收回而丢失的数据。...安卓提供了三种方式用于简单的数据持久化功能 文件储存,SharedPrefer...
  • Android 数据持久化

    2016-12-13 11:41:19
     在讨论数据持久化技术之前我们先了解几个概念? 什么是瞬时数据存储在内存当中,有可能会因为程序的关闭或其他原因导致内存被收回而丢失的数据...安卓提供了三种方式用于简单的数据持久化功能:文件储存,Sha
  • 201.7.19

    2018-07-20 10:08:01
    数据存储全方案---详解持久化技术:  1,数据持久化就是指那些在内存中的瞬时数据被保存到存储设备中,其实关机数据也不会丢失的技术。...3,文件存储是安卓最基本的一种数据存储方式,搜有数据...
  • Android 面试题

    2016-05-14 19:49:37
    安卓体系结构有哪几层数据存储方式有哪些如何启动和停止Service,并描述生命周期Activity和Task的启动模式有哪些,如何定义。安卓支持哪三种类型的图形动画?并分别描述下。广播发送方式有哪些?注册广播的方式有哪几...
  • 百度网盘目前提供PC端、安卓手机客户端、Web端三种平台支持。百度网盘为广大用户提供覆盖多终端的跨平台免费数据共享服务,同时也让开发者拥有云端存储能力,极大降低了开发难度和节约了成本。   与传统的存储...
  • 独立框架:独立开发的api专用框架协议,采用DB、原生代码三种方式独立封装核心库,不附带任何多余指令,代码简洁、速度快; 代码分离:本框架下所有代码与discuz框架分离,与discuz版本和其他插件不冲突,原生代码...

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

安卓三种数据存储方式