sdCard:默认路径在 /storage/sdcard/...

Android支持OpenFileOutput和openFileInput方式访问手机存储器上的文件。
Context提供了如下两个方法来打开应用程序的数据文件夹里的文件IO流:
FileInputStream openFileInput(String name)：打开应用程序的数据文件夹下的name文件对应的输入流
FileOutStream openFileOutput(String name,int mode)：打开应用程序的数据的文件夹下的name文件对应输出流,其中第二个方法的第二个参数是指定打开文件的模式，该模式支持如下值：
Context.MODE_PRIVATE    =  0
Context.MODE_APPEND    =  32768 \\追加
Context.MODE_WORLD_READABLE =  1 \\可读
Context.MODE_WORLD_WRITEABLE =  2 \\可写
除此之外，Context还提供了如下几个方法来访问应用程序的数据文件夹：
getDir(String name,int mode) 在应用程序的数据文件夹下获取或者创建name对应的子目录
File getFilesDir() 获取该应用程序的数据文件夹的绝对路径
String[] fileList() 返回该应用程序的数据文件夹下的指定文件
读写SD卡上的文件的步骤如下：
1、 Environment的getExternalStorageDirectory方法来判断手机上是否插了SD卡，并且应用程序具有读写SD卡的权限。Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)
2、调用Environment的getExternalStorageDirectory方法来获得外部存储卡，也就是SD卡的路径
3、使用FileInputStream、FileOutputStream、FileReader和FileWriter读写SD卡的内容
为了能读写SD卡上的数据，必须在应用程序的清单文件中添加读写SD卡的权限

<!-- 允许用户创建和删除sdcard卡上的内容 -->

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

<!-- 允许用户往sdcard卡上写入的内容 -->

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

为了能单元测试，必须在应用程序的清单文件中添加工具instrument并在清单文件应用标签中注册单元测试库（图形化界面添加方便）

<!-- 允许用户单元测试 -->
<instrumentation android:targetPackage="com.example.android_06storage" android:name="android.test.InstrumentationTestRunner"></instrumentation>
<!-- 添加在应用标签中 -->
<uses-library android:name="android.test.runner"/>
  1.  <?xml version="1.0" encoding="utf-8"?>
  2.  <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.      package="com.example.android_06storage"
  4.      android:versionCode=""
  5.      android:versionName="1.0" >
  6.  
  7.      <uses-sdk
  8.          android:minSdkVersion=""
  9.          android:targetSdkVersion="" />
  10.      <!-- 添加读写授权 -->
  11.  
  12.      <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
  13.      <instrumentation android:targetPackage="com.example.android_06storage" android:name="android.test.InstrumentationTestRunner"></instrumentation>
  14.  
  15.      <application
  16.          android:allowBackup="true"
  17.          android:icon="@drawable/ic_launcher"
  18.          android:label="@string/app_name"
  19.          android:theme="@style/AppTheme" >
  20.          <!-- 添加 -->
  21.          <uses-library android:name="android.test.runner"/>
  22.          <activity
  23.              android:name=".MainActivity"
  24.              android:label="@string/app_name" >
  25.              <intent-filter>
  26.                  <action android:name="android.intent.action.MAIN" />
  27.  
  28.                  <category android:name="android.intent.category.LAUNCHER" />
  29.              </intent-filter>
  30.          </activity>
  31.      </application>
  32.  
  33.  </manifest>

读取sdCard代码：

  1.  package com.example.android_06storage;
  2.  
  3.  import java.io.ByteArrayOutputStream;
  4.  import java.io.File;
  5.  import java.io.FileInputStream;
  6.  import java.io.FileNotFoundException;
  7.  import java.io.FileOutputStream;
  8.  import java.io.IOException;
  9.  
  10.  import android.content.Context;
  11.  import android.os.Environment;
  12.  
  13.  public class FileService {
  14.  
  15.      private Context context;
  16.      public FileService() {
  17.          // TODO Auto-generated constructor stub
  18.      }
  19.      public FileService(Context context) {
  20.          // TODO Auto-generated constructor stub
  21.          this.context=context;
  22.      }
  23.  
  24.      /**
  25.       *
  26.       * @param fileName文件名
  27.       * @param Content文件内容
  28.       * @return
  29.       * @throws Exception
  30.       */
  31.      public  boolean saveContentToSdcard(String fileName,String Content) throws Exception{
  32.          boolean flag=false;
  33.          FileOutputStream fileOutputStream=null;
  34.          File file=new File(Environment.getExternalStorageDirectory(),fileName);
  35.          if(Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())){
  36.              try {
  37.                  fileOutputStream=new FileOutputStream(file);
  38.                  fileOutputStream.write(Content.getBytes());
  39.                  flag=true;
  40.              } catch (FileNotFoundException e) {
  41.                  // TODO Auto-generated catch block
  42.                  e.printStackTrace();
  43.              }
  44.              finally{
  45.                  if(fileOutputStream!=null)
  46.                      fileOutputStream.close();
  47.              }
  48.  
  49.          }
  50.          return flag;
  51.      }
  52.      public String getDataFromSdcard(String fileName){
  53.          FileInputStream fileInputStream=null;
  54.          ByteArrayOutputStream out=new ByteArrayOutputStream();
  55.          File file=new File(Environment.getExternalStorageDirectory(),fileName);
  56.          if(Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())){
  57.              try {
  58.                  fileInputStream=new FileInputStream(file);
  59.                  int len=;
  60.                  byte[] data=new byte[];
  61.                  while((len=fileInputStream.read(data))!=-){
  62.                      out.write(data, , len);
  63.                  }
  64.              } catch (FileNotFoundException e) {
  65.                  // TODO Auto-generated catch block
  66.                  e.printStackTrace();
  67.              } catch (IOException e) {
  68.                  // TODO Auto-generated catch block
  69.                  e.printStackTrace();
  70.              }finally{
  71.                  if(fileInputStream!=null)
  72.                      try {
  73.                          fileInputStream.close();
  74.                      } catch (IOException e) {
  75.                          // TODO Auto-generated catch block
  76.                          e.printStackTrace();
  77.                      }
  78.              }
  79.          }
  80.          return new String (out.toByteArray());
  81.  
  82.      }
  83.  }

测试类：

  1.  package com.example.android_06storage;
  2.  
  3.  import android.content.Context;
  4.  import android.test.AndroidTestCase;
  5.  import android.util.Log;
  6.  
  7.  public class myTest extends AndroidTestCase {
  8.  
  9.      private static final String TAG="myTest";
  10.      public myTest() {
  11.          // TODO Auto-generated constructor stub
  12.      }
  13.  
  14.      public void saveFile() throws Exception{
  15.          Context context=getContext();
  16.          FileService fileService=new FileService(context);
  17.          boolean flag=fileService.saveContentToSdcard("hello.txt", "你好 阳光");
  18.          System.out.println(flag);
  19.          Log.i(TAG, "---->>"+flag);
  20.  
  21.      }
  22.      public void readFile() throws Exception{
  23.          Context context=getContext();
  24.          FileService fileService=new FileService(context);
  25.          String msg=fileService.getDataFromSdcard("hello.txt");
  26.          System.out.println(msg);
  27.          Log.i(TAG, "---->>"+msg);
  28.  
  29.      }
  30.  }

读取raw文件夹中获取文件：InputStream in = getResources().openRawResource(R.raw.a);

读取asset文件夹中获取文件：

InputStream in = getResources().getAssets().open(fileName);
EncodingUtils.getString(buffer, “UTF-8”);//解决中文乱码的问题
ØAndroid 获取assets的绝对路径 第一种方法：String path = "file:///android_asset/文件名";
                                            第二种方法：InputStream abpath = getClass().getResourceAsStream("/assets/文件名");
注意：资源文件只能读不能写
sharedPreference：读写key-value对的SharedPreferences参数共享的文件存放方式。默认路径在 /data/data/...
在实际的软件界面设计中，我们需要保存一些系统的参数，例如屏幕大小和亮度、高度等。在没有数据的情况下我们把这些参数设置到参数共享的文件中以便下次访问。
SharedPreferences用法的基本步骤：
step1、SharedPreferences preferences =context.getSharedPreferences("login",Context.MODE_PRIVATE);
step2、通过SharedPreferences .edit方法获得一个Editor对象。
step3、通过SharedPreferences 的Editor.putXXX方法放置键值对保存到文件中。
step4、最后调用commit方法保存文件。
注意：只有事务结束之后才能提交。
存取共享文件中的内容代码：
  1.  package com.example.android_06storage_sharedpreference;
  2.  
  3.  import java.util.HashMap;
  4.  import java.util.Map;
  5.  
  6.  import android.content.Context;
  7.  import android.content.SharedPreferences;
  8.  
  9.  public class SharedPreference {
  10.  
  11.      private Context context;
  12.  
  13.      public SharedPreference() {
  14.          // TODO Auto-generated constructor stub
  15.      }
  16.  
  17.      public SharedPreference(Context context) {
  18.          // TODO Auto-generated constructor stub
  19.          this.context=context;
  20.      }
  21.      public boolean SaveKVmessage(String name,String pwd){
  22.          boolean flag=false;
  23.          SharedPreferences share=context.getSharedPreferences("userinfo", context.MODE_PRIVATE);
  24.          //对数据进行编辑
  25.          SharedPreferences.Editor editor=share.edit();
  26.          editor.putString("name", name);
  27.          editor.putString("password", pwd);
  28.          //完成编辑将数据持久化存储到存储介质中
  29.          flag=editor.commit();
  30.          return flag;
  31.      }
  32.      public Map<String,Object> ReadKVmessage(){
  33.          Map<String,Object> map=new HashMap<String, Object>();
  34.  
  35.          SharedPreferences share=context.getSharedPreferences("userinfo", context.MODE_PRIVATE);
  36.  
  37.          String name=share.getString("name", "");
  38.          String password=share.getString("password", "");
  39.  
  40.          map.put("name", name);
  41.          map.put("password", password);
  42.  
  43.          return map;
  44.      }
  45.  }

测试类：

  1.  package com.example.android_06storage_sharedpreference;
  2.  
  3.  import java.util.Map;
  4.  
  5.  import android.content.Context;
  6.  import android.test.AndroidTestCase;
  7.  import android.util.Log;
  8.  
  9.  public class MyTest extends AndroidTestCase {
  10.  
  11.      private static final String TAG="MyTest";
  12.      public  MyTest(){
  13.  
  14.      }
  15.      public void save(){
  16.          Context context=getContext();
  17.          SharedPreference sharedPreference=new SharedPreference(context);
  18.          boolean flag=sharedPreference.SaveKVmessage("admin", "");
  19.          Log.i(TAG, "--->>"+flag);
  20.      }
  21.      public void Read(){
  22.          Context context=getContext();
  23.          SharedPreference sharedPreference=new SharedPreference(context);
  24.          Map<String,Object> map=sharedPreference.ReadKVmessage();
  25.          Log.i(TAG, "--->>"+map.toString());
  26.      }
  27.  }

SQLite数据库的存储：默认路径在 /data/data/...

SQLite数据库是D.Richard Hipp用C语言编写的开源嵌入式数据库，支持的数据库大小为2TB。它具有如下特征：

1、轻量级:SQLite和C\S模式的数据库软件不同，它是进程内的数据库引擎，因此不存在数据库的客户端和服务器。使用SQLite一般只需要带上它的一个动态库，就可以享受它的全部功能。而且那个动态库的尺寸也很小。

2、独立性:SQLite数据库的核心引擎本身不依赖第三方软件，使用它也不需要“安装”，所以在使用的时候能够省去不少麻烦。

3、隔离性:SQLite数据库中的所有信息（比如表、视图、触发器）都包含在一个文件内，方便管理和维护。

4、跨平台:SQLite数据库支持大部分操作系统，除了我们在电脑上使用的操作系统之外，很多手机操作系统同样可以运行，比如Android、Windows Mobile、Symbian、Palm等。

5、多语言接口:SQLite数据库支持很多语言编程接口，比如C\C++、Java、Python、dotNet、Ruby、Perl等，得到更多开发者的喜爱。

6、安全性:SQLite数据库通过数据库级上的独占性和共享锁来实现独立事务处理。这意味着多个进程可以在同一时间从同一数据库读取数据，但只有一个可以写入数据。在某个进程或线程向数据库执行写操作之前，必须获得独占锁定。在发出独占锁定后，其他的读或写操作将不会再发生。

创建一个类，继承SQLiteOpenHelper

　　Android 不自动提供数据库。在 Android 应用程序中使用 SQLite，必须自己创建数据库，然后创建表、索引，填充数据。Android 提供了 SQLiteOpenHelper 帮助你创建一个数据库，你只要继承 SQLiteOpenHelper 类，就可以轻松的创建数据库。

SQLiteOpenHelper 类根据开发应用程序的需要，封装了创建和更新数据库使用的逻辑。SQLiteOpenHelper 的子类，至少需要实现三个方法：

　　构造函数，调用父类 SQLiteOpenHelper 的构造函数

　　onCreate（）方法；// TODO 创建数据库后，对数据库的操作

　　onUpgrage()方法。// TODO 更改数据库版本的操作

　　当你完成了对数据库的操作（例如你的 Activity 已经关闭），需要调用 SQLiteDatabase 的 Close() 方法来释放掉数据库连接。

　　操作数据库的最佳实践是创建一个辅助类，例如联系人模块

　　class ContactsDatabaseHelper extends SQLiteOpenHelper

项目目录如下：

方法1：对于有sql经验的人而言，这种方式比较适合：

增删改 db.execSQL(sql)  查db.rawQuery(sql, params);

首先在db下创建一个DBOpenHelper类继承SQLiteOpenHelper

  1.  package com.example.android_06sotrage_sqlite.db;
  2.  
  3.  import android.content.Context;
  4.  import android.database.DatabaseErrorHandler;
  5.  import android.database.sqlite.SQLiteDatabase;
  6.  import android.database.sqlite.SQLiteDatabase.CursorFactory;
  7.  import android.database.sqlite.SQLiteOpenHelper;
  8.  
  9.  public class DBOpenHelper extends SQLiteOpenHelper {
  10.  
  11.      private static String name="mydb.db";//数据库名称
  12.      private static  int version=;//数据库版本号
  13.  
  14.      public DBOpenHelper(Context context) {
  15.          super(context, name, null, version);
  16.          // TODO Auto-generated constructor stub
  17.          //虽然定义了数据库的名称和版本号，
  18.          //但直到调用getReadableDatabase或getWritableDatabase的时候才最终生成数据库
  19.  
  20.      }
  21.  
  22.  /**
  23.   * 当数据库创建的时候 是第一次被执行
  24.   * 通常用来完成对数据库表的创建
  25.   */
  26.      @Override
  27.      public void onCreate(SQLiteDatabase db) {
  28.          // TODO Auto-generated method stub
  29.          //支持的数据类型：整型数据 字符串 日期类型 二进制数据类型
  30.          String sql="create table person(id integer primary key autoincrement,name varchar(64),address varchar(64))";
  31.          db.execSQL(sql);
  32.      }
  33.  
  34.      @Override
  35.      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  36.          // TODO Auto-generated method stub
  37.          //原来版本创建时 是1  如果设置成>1的数字，则会更新数据库版本，这里只需要执行alter语句就行
  38.          String sql="alter table person add sex varchar(8)";
  39.          db.execSQL(sql);
  40.      }
  41.  
  42.  }

然后在service包下建接口类

  1.  package com.example.android_06sotrage_sqlite.service;
  2.  
  3.  import java.util.List;
  4.  import java.util.Map;
  5.  
  6.  public interface PersonService {
  7.  
  8.      public boolean add(Object[] params);
  9.      public boolean del(Object[] params);
  10.      public boolean mod(Object[] params);
  11.      public Map<String,String> find(String[] params);
  12.      public List<Map<String,String>> findMore(String[] params);
  13.  }

第三在dao包下建实现类

  1.  package com.example.android_06sotrage_sqlite.dao;
  2.  
  3.  import java.util.ArrayList;
  4.  import java.util.HashMap;
  5.  import java.util.List;
  6.  import java.util.Map;
  7.  
  8.  import android.content.Context;
  9.  import android.database.Cursor;
  10.  import android.database.sqlite.SQLiteDatabase;
  11.  
  12.  import com.example.android_06sotrage_sqlite.db.DBOpenHelper;
  13.  import com.example.android_06sotrage_sqlite.service.PersonService;
  14.  
  15.  public class PersonDao implements PersonService {
  16.  
  17.      private DBOpenHelper helper=null;
  18.      public PersonDao(Context context) {
  19.          // TODO Auto-generated constructor stub
  20.          helper=new DBOpenHelper(context);
  21.      }
  22.  
  23.      @Override
  24.      public boolean add(Object[] params) {
  25.          // TODO Auto-generated method stub
  26.          boolean flag=false;
  27.          //SQLiteDatabase实现数据库的增删改
  28.                  SQLiteDatabase database=null;
  29.                  try {
  30.                      String sql="insert into person(name,address) values(?,?)";
  31.                      database=helper.getWritableDatabase();
  32.                      database.execSQL(sql,params);
  33.                      flag=true;
  34.                  } catch (Exception e) {
  35.                      // TODO: handle exception
  36.                      e.printStackTrace();
  37.                  }
  38.                  finally{
  39.                      if(database!=null)
  40.                          database.close();
  41.                  }
  42.          return flag;
  43.      }
  44.  
  45.      @Override
  46.      public boolean del(Object[] params) {
  47.          // TODO Auto-generated method stub
  48.          boolean flag=false;
  49.          SQLiteDatabase database=null;
  50.          try {
  51.              String sql="delete from person where id=?";
  52.              database=helper.getWritableDatabase();
  53.              database.execSQL(sql,params);
  54.              flag=true;
  55.          } catch (Exception e) {
  56.              // TODO: handle exception
  57.              e.printStackTrace();
  58.          }
  59.          finally{
  60.              if(database!=null)
  61.                  database.close();
  62.          }
  63.          return flag;
  64.      }
  65.  
  66.      @Override
  67.      public boolean mod(Object[] params) {
  68.          // TODO Auto-generated method stub
  69.          boolean flag=false;
  70.          SQLiteDatabase database=null;
  71.          try {
  72.              String sql="update person set name=?,address=? where id=?";
  73.              database=helper.getWritableDatabase();
  74.              database.execSQL(sql,params);
  75.              flag=true;
  76.          } catch (Exception e) {
  77.              // TODO: handle exception
  78.              e.printStackTrace();
  79.          }
  80.          finally{
  81.              if(database!=null)
  82.                  database.close();
  83.          }
  84.          return flag;
  85.      }
  86.  
  87.      @Override
  88.      public Map<String, String> find(String[] params) {
  89.          // TODO Auto-generated method stub
  90.          Map<String, String> map=new HashMap<String, String>();
  91.          SQLiteDatabase database=null;
  92.          try {
  93.              String sql="select * from person where id=?";
  94.              database=helper.getReadableDatabase();
  95.              Cursor cursor=database.rawQuery(sql, params);
  96.              //数据库列的个数
  97.              int col=cursor.getColumnCount();
  98.               while(cursor.moveToNext()){
  99.                   for (int i = ; i < col; i++) {
  100.                      String col_name=cursor.getColumnName(i);
  101.                      String col_val=cursor.getString(cursor.getColumnIndex(col_name));
  102.                      if(col_val==null)
  103.                          col_val="";
  104.                      map.put(col_name, col_val);
  105.                  }
  106.  
  107.               }
  108.          } catch (Exception e) {
  109.              // TODO: handle exception
  110.              e.printStackTrace();
  111.          }
  112.          finally{
  113.              if(database!=null)
  114.                  database.close();
  115.          }
  116.          return map;
  117.      }
  118.  
  119.      @Override
  120.      public List<Map<String, String>> findMore(String[] params) {
  121.          // TODO Auto-generated method stub
  122.          List<Map<String, String>>  list=new ArrayList<Map<String,String>>();
  123.          SQLiteDatabase database=null;
  124.          try {
  125.              String sql="select * from person";
  126.              database=helper.getReadableDatabase();
  127.              Cursor cursor=database.rawQuery(sql, params);
  128.              //数据库列的个数
  129.              int col=cursor.getColumnCount();
  130.               while(cursor.moveToNext()){
  131.                   Map<String, String> map=new HashMap<String, String>();
  132.                   for (int i = ; i < col; i++) {
  133.                      String col_name=cursor.getColumnName(i);
  134.                      String col_val=cursor.getString(cursor.getColumnIndex(col_name));
  135.                      if(col_val==null)
  136.                          col_val="";
  137.                      map.put(col_name, col_val);
  138.                  }
  139.                  list.add(map);
  140.               }
  141.          } catch (Exception e) {
  142.              // TODO: handle exception
  143.              e.printStackTrace();
  144.          }
  145.          finally{
  146.              if(database!=null)
  147.                  database.close();
  148.          }
  149.          return list;
  150.      }
  151.  
  152.  }

最后创建测试类：

  1.  package com.example.android_06sotrage_sqlite.test;
  2.  
  3.  import java.util.List;
  4.  import java.util.Map;
  5.  
  6.  import com.example.android_06sotrage_sqlite.dao.PersonDao;
  7.  import com.example.android_06sotrage_sqlite.db.DBOpenHelper;
  8.  import com.example.android_06sotrage_sqlite.service.PersonService;
  9.  
  10.  public class MyTest extends android.test.AndroidTestCase{
  11.  
  12.      public MyTest() {
  13.          // TODO Auto-generated constructor stub
  14.      }
  15.  
  16.      public void createDB(){
  17.          DBOpenHelper helper=new DBOpenHelper(getContext());
  18.          helper.getWritableDatabase();//此时才真正创建了数据库
  19.      }
  20.      public void add(){
  21.          PersonService service=new PersonDao(getContext());
  22.          Object[] params={"mlj","xinxiang"};
  23.          boolean flag=service.add(params);
  24.          System.out.println("--->>"+flag);
  25.      }
  26.      public void del(){
  27.          PersonService service=new PersonDao(getContext());
  28.          Object[] params={};
  29.          boolean flag=service.del(params);
  30.          System.out.println("--->>"+flag);
  31.      }
  32.      public void mod(){
  33.          PersonService service=new PersonDao(getContext());
  34.          Object[] params={"mlj","huojia",""};
  35.          boolean flag=service.mod(params);
  36.          System.out.println("--->>"+flag);
  37.      }
  38.      public void find(){
  39.          PersonService service=new PersonDao(getContext());
  40.          String[] params={""};
  41.          Map<String,String> map=service.find(params);
  42.          System.out.println("--->>"+map.toString());
  43.      }
  44.      public void findMore(){
  45.          PersonService service=new PersonDao(getContext());
  46.          List<Map<String,String>> list=service.findMore(null);
  47.          System.out.println("--->>"+list.toString());
  48.      }
  49.  }

方法2：对于其他人而言，这种方式比较适合，因为不用编写sql语句：

增 db.insert("表名", "列名", 值);

int insert(String table, String nullColumnHack, ContentValues values) 列名可以为空，当values参数为空或者里面没有内容的时候，我们insert是会失败的（底层数据库不允许插入一个空行），

为了防止这种情况，我们要在这里指定一个 列名，到时候如果发现将要插入的行为空行时，就会将你指定的这个列名的值设为null，然后再向数据库中插入。

　　值类似于map类型。

　　返回值为int,如果不等于-1，即表示成功插入

删 db.delete("表名", "不含where的条件字句", 字句中占位符的值);

int delete (String table, String whereClause, String[] whereArgs),返回值为最终影响的行数

改db.update("表名",  值，"不含where的条件字句", 字句中占位符的值);

int update (String table, ContentValues values, String whereClause, String[] whereArgs)返回值为最终影响的行数

查db.query(是否是唯一记录, "表名", 列名可以为空, 字句, 字句占位符的值, 分组可以为空, 过滤可以为空, 排序可以为空, 限制记录可以为空);

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

DBOpenHelper类同上

新建接口类：

  1.  package com.example.android_06sotrage_sqlite.service;
  2.  
  3.  import java.util.List;
  4.  import java.util.Map;
  5.  
  6.  import android.content.ContentValues;
  7.  
  8.  public interface PersonService2 {
  9.  
  10.      public boolean add(ContentValues values);
  11.      public boolean del(String whereClause,String[] whereArgs);
  12.      public boolean mod(ContentValues values, String whereClause, String[] whereArgs);
  13.      public Map<String,String> find(String selection,String[] selectionArgs);
  14.      public List<Map<String,String>> findMore(String selection,String[] selectionArgs);
  15.  }

第三在dao包下建实现类：

  1.  package com.example.android_06sotrage_sqlite.dao;
  2.  
  3.  import java.util.ArrayList;
  4.  import java.util.HashMap;
  5.  import java.util.List;
  6.  import java.util.Map;
  7.  
  8.  import android.content.ContentValues;
  9.  import android.content.Context;
  10.  import android.database.Cursor;
  11.  import android.database.sqlite.SQLiteDatabase;
  12.  
  13.  import com.example.android_06sotrage_sqlite.db.DBOpenHelper;
  14.  import com.example.android_06sotrage_sqlite.service.PersonService2;
  15.  
  16.  public class PersonDao2 implements PersonService2 {
  17.  
  18.      private DBOpenHelper helper=null;
  19.      public PersonDao2(Context context) {
  20.          // TODO Auto-generated constructor stub
  21.          helper=new DBOpenHelper(context);
  22.      }
  23.  
  24.      @Override
  25.      public boolean add(ContentValues values) {
  26.          // TODO Auto-generated method stub
  27.          boolean flag=false;
  28.          long id=-;//返回最终结果值 如果不等于-1，即表示成功插入
  29.          //SQLiteDatabase实现数据库的增删改
  30.                  SQLiteDatabase database=null;
  31.                  try {
  32.                      database=helper.getWritableDatabase();
  33.                      id=database.insert("person", null, values);
  34.                      flag=(id!=-?true:false);
  35.                  } catch (Exception e) {
  36.                      // TODO: handle exception
  37.                      e.printStackTrace();
  38.                  }
  39.                  finally{
  40.                      if(database!=null)
  41.                          database.close();
  42.                  }
  43.          return flag;
  44.      }
  45.  
  46.      @Override
  47.      public boolean del(String whereClause,String[] whereArgs) {
  48.          // TODO Auto-generated method stub
  49.          boolean flag=false;
  50.          int count=;//最终影响的行数
  51.          SQLiteDatabase database=null;
  52.          try {
  53.              database=helper.getWritableDatabase();
  54.              count=database.delete("person", whereClause, whereArgs);
  55.              flag=(count>?true:false);
  56.          } catch (Exception e) {
  57.              // TODO: handle exception
  58.              e.printStackTrace();
  59.          }
  60.          finally{
  61.              if(database!=null)
  62.                  database.close();
  63.          }
  64.          return flag;
  65.      }
  66.  
  67.      @Override
  68.      public boolean mod(ContentValues values, String whereClause, String[] whereArgs) {
  69.          boolean flag=false;
  70.          int count=;//最终影响的行数
  71.          SQLiteDatabase database=null;
  72.          try {
  73.              database=helper.getWritableDatabase();
  74.              count=database.update("person", values, whereClause, whereArgs);
  75.              flag=(count>?true:false);
  76.          } catch (Exception e) {
  77.              // TODO: handle exception
  78.              e.printStackTrace();
  79.          }
  80.          finally{
  81.              if(database!=null)
  82.                  database.close();
  83.          }
  84.          return flag;
  85.      }
  86.  
  87.      @Override
  88.      public Map<String, String> find(String selection,String[] selectionArgs) {
  89.          // TODO Auto-generated method stub
  90.          Map<String, String> map=new HashMap<String, String>();
  91.          SQLiteDatabase database=null;
  92.          try {
  93.              database=helper.getReadableDatabase();
  94.              /**
  95.               * distinct 是否返回唯一值
  96.               * table name表名
  97.               * column name 设置为空   表明所有列
  98.               * selection
  99.               * selectionArgs
  100.               * groupBy null
  101.               * having null
  102.               * orderBy null
  103.               * limit null
  104.               */
  105.              Cursor cursor=database.query(true, "person", null, selection, selectionArgs, null, null, null, null);
  106.              //数据库列的个数
  107.              int col=cursor.getColumnCount();
  108.               while(cursor.moveToNext()){
  109.                   for (int i = ; i < col; i++) {
  110.                       String col_name=cursor.getColumnName(i);
  111.                       String col_val=cursor.getString(cursor.getColumnIndex(col_name));
  112.                        if(col_val==null)
  113.                              col_val="";
  114.                        map.put(col_name, col_val);
  115.                   }
  116.               }
  117.  
  118.          } catch (Exception e) {
  119.              // TODO: handle exception
  120.              e.printStackTrace();
  121.          }
  122.          finally{
  123.              if(database!=null)
  124.                  database.close();
  125.          }
  126.          return map;
  127.      }
  128.  
  129.      @Override
  130.      public List<Map<String, String>> findMore(String selection,String[] selectionArgs) {
  131.          // TODO Auto-generated method stub
  132.          List<Map<String, String>>  list=new ArrayList<Map<String,String>>();
  133.          SQLiteDatabase database=null;
  134.          try {
  135.              database=helper.getReadableDatabase();
  136.              Cursor cursor=database.query(false, "person", null, selection, selectionArgs, null, null, null, null);
  137.              //数据库列的个数
  138.              int col=cursor.getColumnCount();
  139.               while(cursor.moveToNext()){
  140.                   Map<String, String> map=new HashMap<String, String>();
  141.                   for (int i = ; i < col; i++) {
  142.                      String col_name=cursor.getColumnName(i);
  143.                      String col_val=cursor.getString(cursor.getColumnIndex(col_name));
  144.                      if(col_val==null)
  145.                          col_val="";
  146.                      map.put(col_name, col_val);
  147.                  }
  148.                  list.add(map);
  149.               }
  150.          } catch (Exception e) {
  151.              // TODO: handle exception
  152.              e.printStackTrace();
  153.          }
  154.          finally{
  155.              if(database!=null)
  156.                  database.close();
  157.          }
  158.          return list;
  159.      }
  160.  
  161.  }

最后创建测试类：

  1.  package com.example.android_06sotrage_sqlite.test;
  2.  
  3.  import java.util.List;
  4.  import java.util.Map;
  5.  
  6.  import android.content.ContentValues;
  7.  
  8.  import com.example.android_06sotrage_sqlite.dao.PersonDao2;
  9.  import com.example.android_06sotrage_sqlite.db.DBOpenHelper;
  10.  import com.example.android_06sotrage_sqlite.service.PersonService2;
  11.  
  12.  public class MyTest2 extends android.test.AndroidTestCase{
  13.  
  14.      public MyTest2() {
  15.          // TODO Auto-generated constructor stub
  16.      }
  17.  
  18.      public void createDB(){
  19.          DBOpenHelper helper=new DBOpenHelper(getContext());
  20.          helper.getWritableDatabase();//此时才真正创建了数据库
  21.      }
  22.      public void add(){
  23.          PersonService2 service=new PersonDao2(getContext());
  24.          ContentValues values=new ContentValues();//类似于map
  25.          values.put("name", "zhh");
  26.          values.put("address", "henan");
  27.          service.add(values);
  28.          boolean flag=service.add(values);
  29.          System.out.println("--->>"+flag);
  30.      }
  31.      public void del(){
  32.          PersonService2 service2=new PersonDao2(getContext());
  33.           /**
  34.            * whereClause 条件字句
  35.            * 原来sql语句是"delete from person where id=? "
  36.            * 现在的字句不包含where关键字
  37.            * whereArgs 字句中的参数列表
  38.            */
  39.          boolean flag=service2.del("id=?", new String[]{""});
  40.          System.out.println("--->>"+flag);
  41.      }
  42.      public void mod(){
  43.          PersonService2 service2=new PersonDao2(getContext());
  44.          ContentValues values=new ContentValues();//类似于map
  45.          values.put("name", "zhh");
  46.          values.put("address", "jiaozuo");
  47.          boolean flag=service2.mod(values, "id=?", new String[]{""});
  48.      }
  49.      public void find(){
  50.          PersonService2 service2=new PersonDao2(getContext());
  51.          Map<String,String> map=service2.find("id=?", new String[]{""});
  52.          System.out.println("--->>"+map.toString());
  53.  
  54.      }
  55.      public void findMore(){
  56.          PersonService2 service2=new PersonDao2(getContext());
  57.          //select * from person
  58.          List<Map<String,String>> list=service2.findMore(null, null);
  59.          System.out.println("--->>"+list.toString());
  60.      }
  61.  }

Android 之数据存储(sdCard,sharedPreference,sqlite数据库)的更多相关文章

  1. <Android基础> (六) 数据存储 Part 3 SQLite数据库存储

    6.4 SQLite数据库存储 SQLite是一种轻量级的关系型数据库,运算速度快,占用资源少. 6.4.1 创建数据库 Android为了管理数据库,专门提供了SQLiteOpenHelper帮助类 ...

  2. Android中数据存储（三）——SQLite数据库存储数据

    当一个应用程序在Android中安装后,我们在使用应用的过程中会产生很多的数据,应用都有自己的数据,那么我们应该如何存储数据呢? 数据存储方式 Android 的数据存储有5种方式: 1. Share ...

  3. Android 数据存储03之SQLite

    SQLite数据存储 Android 集成了 SQLite 数据库.它存储在 /data/data/< 项目文件夹 >/databases/ 下.Android 开发中使用 SQLite ...

  4. Android本地数据存储复习

    Android本地数据存储复习 Android无论是应用层还是系统层都需要在本地保存一些数据,尤其在应用层中使用的就更为普遍,大体有这么几种:SharedPreference,file,sqlite数 ...

  5. Android实现数据存储技术

    转载:Android实现数据存储技术 本文介绍Android中的5种数据存储方式. 数据存储在开发中是使用最频繁的,在这里主要介绍Android平台中实现数据存储的5种方式,分别是: 1 使用Shar ...

  6. Android中数据存储（四）——ContentProvider存储数据

    目录(?)[+]   当一个应用程序在Android中安装后,我们在使用应用的过程中会产生很多的数据,应用都有自己的数据,那么我们应该如何存储数据呢? 数据存储方式 Android 的数据存储有5种方 ...

  7. 关于Android开发数据存储的方式（一）

    关于Android开发数据存储方式(一) 在厦门做Android开发也有两个月了,快情人节了.我还在弄代码. 在微信平台上开发自己的APP,用到了数据存储的知识,如今总结一下: 整体的来讲.数据存储方 ...

  8. android中数据存储

    android中数据存储     Android 中存储数据的方式有五种:SQLite数据库.文件存储.内容提供者.网络.SharedPreferences(Key----value)五种存储方式. ...

  9. Android中数据存储(一)

    国庆没有给国家添堵,没有勾搭妹子,乖乖的写着自己的博客..... 本文将为大家介绍Android中数据存储的五种方式,数据存储可是非常重要的知识哦. 一,文件存储数据 ①在ROM存储数据 关于在ROM ...

随机推荐

  1. 《CS:APP》二进制炸弹实验(phase_1-3)

    <深入理解计算机系统>第三章的bomb lab,拆弹实验:给出一个linux的可执行文件bomb,执行后文件要求分别进行6次输入,每一次输入错误都会导致炸弹爆炸,程序终止.需要通过反汇编来 ...

  2. Nginx入门案例（Mac版）

    Nginx(engine x)是一个轻量级.高性能的Web和反向代理服务器,也是一个IMAP.POP3和SMTP服务器,并且安装十分简单,配置文件非常简洁,启动特别容易,运行十分稳定,几乎可以做到7* ...

  3. 安全终端模拟工具Xshell 5使用密钥认证登录配置详细教程

    ▲版权声明:本文为博主原创文章,未经博主允许不得转载. Xshell支持SSH1 / SSH2协议,密码和DSA / RSA公钥用户认证方式等各种安全功能,并对各种加密算法进行加密.使用内置的Xshe ...

  4. Android SharedPreferences基本用法

    使用SharedPreferences SharedPreferences是Android平台上一个轻量级的存储类, 用来保存应用的一些常用配置. SharedPreferences与Editor简介 ...

  5. asp.net mvc 接入阿里大于 短信验证码发送

    项目前端页面实例 第1步:登录阿里大于控制台 https://www.alidayu.com/center/user/account?spm=0.0.0.0.P1K1jG 第2步:创建应用 第3步:配 ...

  6. 新博客在SEO方面需要注意哪几点？

    无论是什么程序的博客,都应该注意这重要的几点! 第一点:网站目标明确进入主题,有些人对于SEO不是特别熟悉,或者说没有接触过.当你做好一个网站,不管网站内容是什么,首先你都得了解最基本的SEO,比如网 ...

  7. CRF技能词识别过程

    最近在用CRF做未登录技能词识别,虽然艰难,但是感觉很爽,效率非常高. (1)数据准备: 选取30000行精语料作为训练数据.每一个br作为一条数据.使用已有的技能词典对数据进行无标注分词. (2)训 ...

  8. geotrellis使用（三十一）使用geotrellis直接将GeoTiff发布为TMS服务

    前言 传统上我们需要先将Tiff中存储的影像等数据先切割成瓦片,而后再对外提供服务.这样的好处是服务器响应快,典型的用空间来换时间的操作.然而这样造成的问题是空间的巨大浪费,一般情况下均需要存储1-1 ...

  9. Junit4的最简单例子

    首先是JUnit的百度百科介绍: 接下来是JUnit4的最简单例子,使用的开发软件为Eclispe(里面集成了JUnit): 1.建立一个java project: 2.建立一个java class: ...

  10. 设置为互斥按钮的一组Radio按钮的用法

    设置为互斥按钮的一组Radio,只需要将第一个Radio的Group属性设置为True,并为之映射变量(DDX),其余radio的Group属性设置为False,不需要映射变量. 否则会出现不是互斥按 ...