数据库存储
手机自带的数据库一般都叫文本数据库
①不需要安装，里面存储的数据类型比较单一，能力较弱，数据量不大
②是文件，只要知道用户名和密码都可以去打开查看
存储的方式： SQLite Database : 存储结构化数据到私有数据库
简介：
安卓提供了支持SQLite数据库的存储，任意数据库在创建完后，在应用的任何的一个类当中都可以按照一定的名称来访问，不能在外部访问本应用的数据库，除非内容提供者提供。
创建一个SQLite数据库： 我们需要SQLiteOpenHelper 重写 onCreate() ，在里面执行SQLite 的一些命令
SQLiteOpenHelper 用于管理数据库 创建数据库 包含一些版本。
此类必须重写两个抽象方法 onCreate( SQLiteDatabase ) , onUpgrade( SQLiteDatebase , int , int ) 可选可选项是 onOpen(SQLiteDatabase)；
特点：这个类会很小心地去打开数据库，如果不存在就创建,或者升级，如果有需要还提供事务。实例化子类时的构造返回非常快，但是不会马上创建数据库，一定是在调用 getWritableDatabase()或者getReadableDatabase() 后才创建
getReadableDatabase() ：表示要查询文件，
getWritableDatabase()：表示写文件，也叫操作文件
以上两种方法都会返回一个同名SQLitedatabase对象，除非出现磁盘满了。此时数据库只能被读。在某些问题的整改中，我们可以调用 getWritebalDatabase(); 返回一个数据库的对象，在调用getWritebalDatabase()或者close()方法的时候不被使用；一旦打开成功数据库，在确认使用完毕后一定要close()执行关闭数据库。
onOpen(SQLitedatabase db)可选方法//当数据库较大时，移植到SDcard()
//当我们支持插入数据的时候，都会调用onOpen 方法
实例：
public class DBHelper extends SQLiteOpenHelper{
private static final String DB_NAME="mydb.db"; //
private static final int VERSON =1;
//public DBHelper ( Context contex , String name , CursorFactory factoru, int version )
//name 数据库名
//factory 默认空
//version 版本从1开始 //应用模块内容变更需要
//由于不方便构造，我们采用以下方法
public DBHelper(Context context){
super(context ,DB_NAME, null ,VERSON);
}
public void onCreate( SQLiteDatabase db ){
//操作数据的前提条件下先执行，且仅被执行一次，如果数据库被删除，该方法会再一次执行，如果数据库的文件一直存在，那么该方法就只能被调用一次
//数据库创建的第一次被调用，一般用户创建表和初始化表的内容数据
//数据库的类型是不确认的例如：boolean 存 varchar
//数据类型：varchar int long float boolean text blob(二进制) clob(大数据类型)
String sql = "create table person (pid integer primary key autoincrement,name varchar(64))";
db.execSQL(sql);
String s = "create table if not exists upgrade( _id intrger primarykey autoincremet null, version_code varchar(10) null , connection vachar(32) null);";
String news_content = "create table if not exists newlist ( item integer primarykey null , newsid integer null , title varchar null, url varchar null, postdate varchar null, image varchar null, description varchar null , hitcournt integer null, commentcourt integer nulll, forbidcomment bool null , tags varchar(16) null);";
db.execSQL(s);
}
onUpgrade ( SQLiteDatabase db , int oldVersion , int new Version ){
//①先更改版本号，一旦存在数据库就不会再去执行OnCreate()方法了
//此方法用户数据库升级，删除表，添加表，或者可以在数据表里面添加或修改字段
// 如果我们想添加一个字段，使用 ALTER TABLE to insert 移除一个字段使用 ALTER TABLE to remove
//当版本发生改变的时候会自动调用（针对已发表的应用）
String sql = "alter table person and age integer"
db.execSQL(sql);
}
public void onOpen(SQLiteDatabase db){
super.onOpen(db);
//涉及到加载数据库
System.out.println("-----onOpen--->>");
}
封装
调用execSQ(String sql)//该方法可以用，但是不推荐用
执行一条单独的SQL语句，它不是查询语句，没有返回值
如果想执行插入语句，推荐我们使用
insert(String, String, ContentValues),
update(String ,ContentValues, String ,String[])
public class DBManager{
private DBHelper helper;
private SQLiteDatabase database;
public DBManager(Context context) {
helper = new DBHelper(context);
database = helper.getWriterbleDatabase();
// DBHelper继承 SQLiteOpenHelper.所以可以调用
// helper.getWritableDatabase();
}
//以下为封装的方法
/**
* 实现对数据库的添加，删除，修改功能
*
* @param sql
* @param bindArgs
* @return
*/
public boolean updataBySQL(String sql, Object[] bindArgs) {
boolean flag = false;
try {
// 因为execSQL()方法没有返回值，虽然没有必要抓异常，但可以自定义返回一个值
database.execSQL(sql, bindArgs);
flag = true;
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
} finally {
if (database != null) {
database.close();
}
}
return flag;
}
/**
*
* @param sql
* @param selectionArgs
* @return
*/
public Map<String, String> queryBySQL(String sql, String[] selectionArgs) {
Map<String, String> map = new HashMap<String, String>();
Cursor cursor = database.rawQuery(sql, selectionArgs);
int cols_len = cursor.getColumnCount();
while (cursor.moveToNext()) {
for (int i = 0; i < cols_len; i++) {
String cols_name = cursor.getColumnName(i);
String cols_value = cursor.getString(cursor
.getColumnIndex(cols_name));
if (cols_value == null) {
cols_value = "";
}
map.put(cols_name, cols_value);
}
}
return map;
}
/**
*
* @param sql
* @param selectionArgs
* @return
*/
public List<Map<String, String>> queryMultiMaps(String sql,
String[] selectionArgs) {
List<Map<String, String>> list = new ArrayList<Map<String, String>>();
Cursor cursor = database.rawQuery(sql, selectionArgs);
int cols_len = cursor.getColumnCount();
while (cursor.moveToNext()) {
Map<String, String> map = new HashMap<String, String>();
for (int i = 0; i < cols_len; i++) {
String cols_name = cursor.getColumnName(i);
String cols_value = cursor.getString(cursor
.getColumnIndex(cols_name));
if (cols_value == null) {
cols_value = "";
}
map.put(cols_name, cols_value);
}
list.add(map);
}
return list;
}
public Cursor queryMultiCursor(String sql, String[] selectionArgs) {
Cursor cursor = database.rawQuery(sql, selectionArgs);
return cursor;
}
/**
* 声明Class 的属性必须是String 类型
*
* @param sql
* @param selectionArgs
* @param cls
* 通过反射获得数据查询记录
* @return
*/
public <T> T querySingleCursor(String sql, String[] selectionArgs,
Class<T> cls) {
T t = null;
Cursor cursor = database.rawQuery(sql, selectionArgs);
int cols_len = cursor.getColumnCount();
while (cursor.moveToNext()) {
try {
t = cls.newInstance();
for (int i = 0; i < cols_len; i++) {
String cols_name = cursor.getColumnName(i);
String cols_value = cursor.getString(cursor
.getColumnIndex(cols_name));
if (cols_value == null) {
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
field.setAccessible(true);
field.set(t, cols_value);
}
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return t;
}
/**
*
* @param sql
* @param selectionArgs
* @param cls
* @return
*/
public <T> List<T> queryMultiCursor(String sql, String[] selectionArgs,
Class<T> cls) {
List<T> list = new ArrayList<T>();
Cursor cursor = database.rawQuery(sql, selectionArgs);
int cols_len = cursor.getColumnCount();
while (cursor.moveToNext()) {
try {
T t = cls.newInstance();
for (int i = 0; i < cols_len; i++) {
String cols_name = cursor.getColumnName(i);
String cols_value = cursor.getString(cursor
.getColumnIndex(cols_name));
if (cols_value == null) {
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
field.setAccessible(true);
field.set(t, cols_value);
list.add(t);
}
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return list;
}
}
//以下不需要数据库语句
特别注意：在构造的时候
public DBManager(Context context) {
helper = new DBHelper(context);
不要调用以下方法，每使用一次数据库就主动调用数据库链接，用后关闭，再用再连接。
// helper.getWritableDatabase();
}
例如：
public void query4() {
DBManager manager = new DBManager(getContext());
// 获取连接
manager.getDataBaseConn();
Cursor cursor = manager.query(false, "person", null, null, null, null,
null, null, null);
while (cursor.moveToNext()) {
System.out.println("-->>>"
+ cursor.getString(cursor.getColumnIndex("name")));
}
// 关闭连接
manager.releaseConn();
}
public void query4() {
DBManager manager = new DBManager(getContext());
// 获取连接
manager.getDataBaseConn();
Cursor cursor = manager.query(false, "person", null, null, null, null,
null, null, null);
while (cursor.moveToNext()) {
System.out.println("-->>>"
+ cursor.getString(cursor.getColumnIndex("name")));
}
// 关闭连接
manager.releaseConn();
}
public boolean insert(String table, String nullColumnHack,
ContentValues values) {
boolean flag = false;
// values 具有Map属性，可以包含一些初始化队列对应的行，它 的Keys就是列名，values就是列值
// Return 如果成功返回一个插入的新行。-1表示错误
// insert into tableName(a,b,c)values(?,?,?);
long id = database.insert(table, nullColumnHack, values);
flag = (id > 0 ? true : false);
return flag;
}
/**
* update tableName set name =?, address =?,age=?where pid =?
*
* @param table
* @param values
* @param whereClause
* @param whereArgs
* @return 影响数据的行数
*/
public boolean update(String table, ContentValues values,
String whereClause, String[] whereArgs) {
// values为空表示什么都不会改
// whereClause 可选项，设置的时候添加的额外条件，如果whereClause传空值就会改掉所有的值
boolean flag = false;
int count = database.update(table, values, whereClause, whereArgs);
flag = (count > 0 ? true : false);
return flag;
}
/**
* delete from tableName where pid =?
*
* @param table
* @param whereClause
* @param whereArgs
* @return
*/
public boolean delete(String table, String whereClause, String[] whereArgs) {
boolean flag = false;
int count = database.delete(table, whereClause, whereArgs);
flag = (count > 0 ? true : false);
return flag;
}
/**
* []表示可选项 Sql标准写法：select [distinct][columnName]，...from tableName
* [where][selection][selectionArgs][groupBy][having][order by][limit]
*
* @param distinct (如果为true,表示我们需要行是的唯一的)
* 去掉重复记录
* @param table
* 表名
* @param columns (如果传空，表示要求查询所以的列)
* 列名
* @param selection (过滤返回的行的结果，格式化这条SQL语句，不包含where语句，如果输入空返回所有行)
* 查询的过滤条件
* @param selectionArgs (可以包含多个"?"这个问号会被值替换掉，而且这个值是有序的出现在selection当中)
* 过滤条件的值
* @param groupBy (表示分组并且不包含"groupBy"这个关键字本身，设置空表示不分组)
* 分组
* @param having (表示分组之后进行过滤，也不包含HAVING 本身，设置空表示不对分组进行过滤)
* 对分组进行条件过滤
* @param orderBy (排序且不包含 ORDERBY 本身，设置为空，默认排序)
* 排序
* @param limit (返回一定的行的个数，设置为空表示没有任何的效果)
* 分页
* @return
*/
public Cursor query(boolean distinct, String table, String[] columns,
String selection, String[] selectionArgs, String groupBy,
String having, String orderBy, String limit) {
Cursor cursor = null;
cursor = database.query(distinct, table, columns, selection,
selectionArgs, groupBy, having, orderBy, limit);
return cursor;
}
/**
* 获取数据库的连接
*/
public void getDataBaseConn(){
database =helper.getWritableDatabase();
}
/**
* 关闭数据库
*/
public void releaseConn(){
if(database!=null){
database.close();
}
}
public boolean insert(String table, String nullColumnHack,
ContentValues values) {
boolean flag = false;
// values 具有Map属性，可以包含一些初始化队列对应的行，它 的Keys就是列名，values就是列值
// Return 如果成功返回一个插入的新行。-1表示错误
// insert into tableName(a,b,c)values(?,?,?);
long id = database.insert(table, nullColumnHack, values);
flag = (id > 0 ? true : false);
return flag;
}
/**
* update tableName set name =?, address =?,age=?where pid =?
*
* @param table
* @param values
* @param whereClause
* @param whereArgs
* @return 影响数据的行数
*/
public boolean update(String table, ContentValues values,
String whereClause, String[] whereArgs) {
// values为空表示什么都不会改
// whereClause 可选项，设置的时候添加的额外条件，如果whereClause传空值就会改掉所有的值
boolean flag = false;
int count = database.update(table, values, whereClause, whereArgs);
flag = (count > 0 ? true : false);
return flag;
}
/**
* delete from tableName where pid =?
*
* @param table
* @param whereClause
* @param whereArgs
* @return
*/
public boolean delete(String table, String whereClause, String[] whereArgs) {
boolean flag = false;
int count = database.delete(table, whereClause, whereArgs);
flag = (count > 0 ? true : false);
return flag;
}
/**
* []表示可选项 Sql标准写法：select [distinct][columnName]，...from tableName
* [where][selection][selectionArgs][groupBy][having][order by][limit]
*
* @param distinct (如果为true,表示我们需要行是的唯一的)
* 去掉重复记录
* @param table
* 表名
* @param columns (如果传空，表示要求查询所以的列)
* 列名
* @param selection (过滤返回的行的结果，格式化这条SQL语句，不包含where语句，如果输入空返回所有行)
* 查询的过滤条件
* @param selectionArgs (可以包含多个"?"这个问号会被值替换掉，而且这个值是有序的出现在selection当中)
* 过滤条件的值
* @param groupBy (表示分组并且不包含"groupBy"这个关键字本身，设置空表示不分组)
* 分组
* @param having (表示分组之后进行过滤，也不包含HAVING 本身，设置空表示不对分组进行过滤)
* 对分组进行条件过滤
* @param orderBy (排序且不包含 ORDERBY 本身，设置为空，默认排序)
* 排序
* @param limit (返回一定的行的个数，设置为空表示没有任何的效果)
* 分页
* @return
*/
public Cursor query(boolean distinct, String table, String[] columns,
String selection, String[] selectionArgs, String groupBy,
String having, String orderBy, String limit) {
Cursor cursor = null;
cursor = database.query(distinct, table, columns, selection,
selectionArgs, groupBy, having, orderBy, limit);
return cursor;
}
/**
* 获取数据库的连接
*/
public void getDataBaseConn(){
database =helper.getWritableDatabase();
}
/**
* 关闭数据库
*/
public void releaseConn(){
if(database!=null){
database.close();
}
}
以下为测试的案例
public class Mytest extends AndroidTestCase {
// 特别注意close();
public Mytest() {
}
public void initTable() {
try {
DBHelper dbManager = new DBHelper(getContext());
// 必须调用以下其中一个方法才会创建数据库，否则即使实例化也不会成功；
// dbManager.getWritableDatabase();
dbManager.getReadableDatabase();
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
}
public void insert() {
String sql = "insert into person(name,address,age) values (?,?,?)";
Object[] bindArgs = { "张三", "北京", 32 };
DBManager manager = new DBManager(getContext());
manager.updataBySQL(sql, bindArgs);
}
public void insert2() {
System.out.println("==插入数据===>");
String sql = "insert into person(name,address,age) values (?,?,?)";
Object[] bindArgs = { "张三丰", "北京", 44 };
DBManager manager = new DBManager(getContext());
manager.updataBySQL(sql, bindArgs);
}
public void update() {
String sql = "update person set name = ?, address =? ,age= ? where pid =?";
Object[] bindArgs = { "张三丰", "河北", 120, 1 };
DBManager manager = new DBManager(getContext());
manager.updataBySQL(sql, bindArgs);
}
public void delete() {
String sql = "delete from person where pid =?";
Object[] bindArgs = { 1 };
DBManager manager = new DBManager(getContext());
manager.updataBySQL(sql, bindArgs);
}
public void query() {
try {
String sql = "select * from person";
DBManager manager = new DBManager(getContext());
manager.queryBySQL(sql, null);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
System.out.println("=====>查询出错了");
}
}
public void query2() {
String sql = "select * from person where pid=?";
DBManager manager = new DBManager(getContext());
Map<String, String> map = manager.queryBySQL(sql, new String[] { "2" });
System.out.println("======>name" + map.get("name"));
System.out.println("=====>address" + map.get("address"));
System.out.println("====age" + map.get("age"));
}
public void query3() {
String sql = "select * from person where name like ?";
DBManager manager = new DBManager(getContext());
List<Map<String, String>> list = manager.queryMultiMaps(sql,
new String[] { "%张%" });
for (Map<String, String> map2 : list) {
System.out.println("======>name" + map2.get("name"));
System.out.println("=====>address" + map2.get("address"));
System.out.println("====age" + map2.get("age"));
}
}
}
查询：
public Cursor rawQuery(String sql, String [] selectionArhs)
返回一个可以提供SQL语句，并且返回一个覆盖结果集的游标；
sql 这条查询语句必须不能出现"；"
selectionArgs 在查询语句中应包含多个“?”该值替换values并且绑定在字符串当中
返回的 Cursor 对象 ，当前的位置是在第一条记录的前面
void queryBySQL(String sql,String[] selectionArgs)
abstract int getColumnCount();//得到列的个数
abstract int get ClumnIndex();//按照列名得到列的下标
abstract String getColumnName();//按照列的下标得到列名
abstract boolean isFirst()//判断位置是否第一个
abstract boolean moveToFirst();//移动到第一行
abstract boolean moveToNest();//移动到下一行 d
以下方法不用SQL语句
SQLitedatabase
java.lang.Object
|
android.database.sqlite.SQLiteCloseable
|
android.database.sqlit.SQLiteDatabase
该类提供一些对数据库的操作方法
public boolean insert(String table, String nullColumnHack,
ContentValues values) {
//nullColumnHack 一般为空
//values 具有Map属性，可以包含一些初始化队列对应的行，它 的Keys就是列名，values就是列值
//Return 如果成功返回一个插入的新行。-1表示错误
boolean flag = false;
// insert into tableName(a,b,c)values(?,?,?);
return flag;
}