Android中SQLite 使用办法详解

发布时间:2018-11-15  栏目:sqlite  评论:0 Comments

    private Button create_database = null;
    private Button update_database = null;
    private Button insert = null;
    private Button update = null;
    private Button query = null;
    private Button delete = null;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

public synchronized SQLiteDatabase getReadableDatabase() { 
  if (mDatabase != null && mDatabase.isOpen()) { 
    // 如果发现mDatabase不为空并且已经打开则直接返回 
    return mDatabase; 
  } 

  if (mIsInitializing) { 
    // 如果正在初始化则抛出异常 
    throw new IllegalStateException("getReadableDatabase called recursively"); 
  } 

  // 开始实例化数据库mDatabase 

  try { 
    // 注意这里是调用了getWritableDatabase()方法 
    return getWritableDatabase(); 
  } catch (SQLiteException e) { 
    if (mName == null) 
      throw e; // Can't open a temp database read-only! 
    Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e); 
  } 

  // 如果无法以可读写模式打开数据库 则以只读方式打开 

  SQLiteDatabase db = null; 
  try { 
    mIsInitializing = true; 
    String path = mContext.getDatabasePath(mName).getPath();// 获取数据库路径 
    // 以只读方式打开数据库 
    db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY); 
    if (db.getVersion() != mNewVersion) { 
      throw new SQLiteException("Can't upgrade read-only database from version " + db.getVersion() + " to " 
          + mNewVersion + ": " + path); 
    } 

    onOpen(db); 
    Log.w(TAG, "Opened " + mName + " in read-only mode"); 
    mDatabase = db;// 为mDatabase指定新打开的数据库 
    return mDatabase;// 返回打开的数据库 
  } finally { 
    mIsInitializing = false; 
    if (db != null && db != mDatabase) 
      db.close(); 
  } 
} 

        public void onClick(View v) {
            // TODO Auto-generated method stub
            DatabaseHelper database_helper = new
DatabaseHelper(MainActivity.this, “tornadomeet.db”);
            SQLiteDatabase db =
database_helper.getWritableDatabase();
            //直接去名吧tornadomeet对应的那么条记下
            db.delete(“user1”, “name=?” ,new
String[]{“tornadomeet”});
        }

地方几乎种都是常用的查询方式,第一栽最简练,将具有的SQL语句都组织到一个字符串中,使用占位符代替实际参数,selectionArgs就是占有位符实际参数集;下面的几种参数都很类似,columns表示如查询的列所有名称集,selection表示WHERE之后的基准语句,可以下占位符,groupBy指定分组的列名,having指定分组条件,配合groupBy使用,orderBy指定排序的列名,limit指定分页参数,distinct可以指定“true”或“false”表示如无苟过滤重复值。需要专注的是,selection、groupBy、having、orderBy、limit这几乎单参数中无包“WHERE”、“GROUP
BY”、“HAVING”、“ORDER BY”、“LIMIT”等SQL关键字。

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }
}

脚是Cursor对象的常用方法:

  **实验主要有代码和注释(附录有试工程code下充斥链接):

上述三单办法的第一只参数都是代表要操作的表名;insert中的亚个参数表示只要插入的数量列一样排列都为空的语,需要指定此行中有一样列的号,系统以此列设置也NULL,不至于出现谬误;insert中的老三单参数是ContentValues类型的变量,是键值对构成的Map,key代表列名,value代表该列要插入的价;update的老二单参数为非常类似,只不过它是创新该字段key为流行的value值,第三独参数whereClause表示WHERE表达式,比如“age
> ? and age <
?”等,最后的whereArgs参数是占有位符的实在参数值;delete方法的参数为是平等。

  图片 1

图片 2

    public class QueryOnClickListener implements OnClickListener{

世家可以见到,几独关键步骤是,首先判断mDatabase如果不为空都打开并无是只有读模式则直接归,否则一旦mDatabase不为空则加锁,然后起打开或创数据库,比较版本,根据本号来调用相应的法子,为数据库设置新版本号,最后获释旧的不为空的mDatabase并解锁,把新开辟的数据库实例赋予mDatabase,并回到时实例。

  SQLite是如出一辙种植轻量级的小型数据库,虽然较粗,但是效果相对比较完善,一些常见的数据库基本功能也有着,在当今的嵌入式系统受到利用该数据库的于多,因为其占用系统资源很少。Android系统被也未例外,也是应用SQLite,本节遭受即使学习下以andorid中怎么样用该数据库来存放数据,并且针对SQLite完成简单的新建,更新,查询,删除等操作。

Android中SQLite 使用方法详解

  下面是以挨家挨户单击新建一个SQLite数据库按钮,插入记录按钮,更新记录按钮,再次插入记录按钮,删除按钮后adb后高调试的结果:

如若手动去管理Cursor的话语会怪的劳动,还有一定之高风险,处理不当的口舌运行期间就是会出现异常,幸好Activity为咱提供了startManagingCursor(Cursor
cursor)方法,它见面冲Activity的生命周期去管理即底Cursor对象,下面是拖欠办法的印证:

public class MainActivity extends Activity {

咱们整整应用关闭时实行,这个环节容易被忘记,所以朋友等要留心。

**

比方打算从CursorWrapper里获取“_id”对应的列索引,我们就是回查询结果里“id”对应之列索引即可。
最终我们来拘禁一下结果如何:

  数据库插入:

脚就朝着大家介绍一下SQLite常用的操作方法,为了便于,我用代码写于了Activity的onCreate中:

复制代码 代码如下:

关押罢上面的进程之后,大家可能就是亮了好多,如果无是当碰到磁盘空间已满等状况,getReadableDatabase()一般还见面返回跟getWritableDatabase()一样的数据库实例,所以我们于DBManager构造方法中利用getWritableDatabase()获取整个应用所运用的数据库实例是行之。当然如果你真的担心这种情形会生,那么您可先用getWritableDatabase()获取数据实例,如果撞好,再计用getReadableDatabase()获取实例,当然这个时刻你取得之实例只能读不克写了。

        create_database =
(Button)findViewById(R.id.create_database);
        create_database.setOnClickListener(new
CreateDatabaseOnClickListener());
        update_database =
(Button)findViewById(R.id.update_database);
        update_database.setOnClickListener(new
UpdateDatabaseOnClickListener());
        insert = (Button)findViewById(R.id.insert);
        insert.setOnClickListener(new InsertOnClickListener());
        update = (Button)findViewById(R.id.update);
        update.setOnClickListener(new UpdateOnClickListener());
        query = (Button)findViewById(R.id.query);
        query.setOnClickListener(new QueryOnClickListener());
        delete = (Button)findViewById(R.id.delete);
        delete.setOnClickListener(new DeleteOnClickListener());
    }

下面的话说查询操作。查询操作相对于点的几种植操作而复杂些,因为我们常常要当在各种各样的询问条件,所以系统为设想到这种复杂,为咱提供了较为丰富的查询形式:

  删除操作及前方的好像,使用SQLiteOpenHelper中之delete方法,按照指定列名为某个同价值,然后去那漫长记下即可。

db.rawQuery(String sql, String[] selectionArgs); 
db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy); 
db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit); 
db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit); 

  起数据库:

Cursor结果集待注意些什么:一个最为急需留意的是,在咱们的结果集中必须要含有一个“_id”的排列,否则SimpleCursorAdapter就会翻脸不认人,为什么一定要这样为?因为这出自SQLite的正规,主键以“_id”为正规。解决办法有

  图片 3 

末了,他们又返回一个Cursor对象,代表数据集的游标,有接触类似于JavaSE中之ResultSet。

  创新数据库版本:

方就SQLite的着力以,但以实际上开支被,为了能够还好之田间管理和保安数据库,我们见面卷入一个累自SQLiteOpenHelper类的数据库操作类,然后以之看似为底蕴,再包我们的工作逻辑方式。

  试证实:

文中涉及,startManagingCursor方法会根据Activity的生命周期去管理即底Cursor对象的生命周期,就是说当Activity停止时他会晤活动调用Cursor的deactivate方法,禁用游标,当Activity重新归来屏幕时她会调用Cursor的requery方法重新查询,当Activity摧毁时,被管制之Cursor都见面自行关闭释放。

    public class DeleteOnClickListener implements OnClickListener{

图片 4

  本程序将上面插的相同长条记下的name名有tornado改为了tornadomeet,所以当随下update按钮后,重新在cmd使用select \ from
user1*可以看出那条记下变成了1 | tornadomeet了。

以地方的代码示例中,已经使了即几乎独常因此艺术中之局部,关于更多的音信,大家好参照官方文档中之验证。
末尾当我们得了针对性数据库的操作后,记得调用SQLiteDatabase的close()方法释放数据库连接,否则易并发SQLiteException。

    }

图片 5

  public ContentValues ()

中间DBHelper继承了SQLiteOpenHelper,作为护卫与管制数据库的基类,DBManager是树立以DBHelper之上,封装了常用的作业方法,Person是咱的person表对应之JavaBean,MainActivity就是咱们来得的界面。

  Android中采取SQLite数据库时,需要为此adb来帮助调试,如果想当windows下之cmd命令行中使用adb,必须先安排环境变量,我这里是配的用户环境变量path: C:\Program
Files\android-sdk\platform-tools;

然后,我们需要一个DBManager,来封装我们有的工作方法,代码如下:

import android.app.Activity;
import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

此处要注意的是SimpleCursorAdapter的动,当我们采用此适配器时,我们不能不事先拿走一个Cursor对象,这里面有几乎单问题:如何管理Cursor的生命周期,如果包装Cursor,Cursor结果集还急需小心什么。

  继续以cmd命令执行输入sqlite3
tornadomeet.db
;(其中tornadomeet为单击创建数据库后新建立的数据库名称。)输入 .schema;(注意前方有只点)显示如下:

package com.scott.db; 

import android.content.Context; 
import android.database.sqlite.SQLiteDatabase; 
import android.database.sqlite.SQLiteOpenHelper; 

public class DBHelper extends SQLiteOpenHelper { 

  private static final String DATABASE_NAME = "test.db"; 
  private static final int DATABASE_VERSION = 1; 

  public DBHelper(Context context) { 
    //CursorFactory设置为null,使用默认值 
    super(context, DATABASE_NAME, null, DATABASE_VERSION); 
  } 

  //数据库第一次被创建时onCreate会被调用 
  @Override 
  public void onCreate(SQLiteDatabase db) { 
    db.execSQL("CREATE TABLE IF NOT EXISTS person" + 
        "(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)"); 
  } 

  //如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade 
  @Override 
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
    db.execSQL("ALTER TABLE person ADD COLUMN other STRING"); 
  } 
} 

  去除操作:

谢阅读,希望能支援及大家,谢谢大家对本站的支持!

        public void onClick(View v) {
            // 生成contentvallues对象,该对象用来抱多少的
            ContentValues values = new ContentValues();
            values.put(“id”, 1);//注意值的类型要配合
            values.put(“name”, “tornado”);
            DatabaseHelper database_helper = new
DatabaseHelper(MainActivity.this, “tornadomeet.db”);
            SQLiteDatabase db =
database_helper.getWritableDatabase();//这里是赢得可写的数据库
            db.insert(“user1”, null, values);
        }      
    }

争包装Cursor:我们见面采取及CursorWrapper对象去包我们的Cursor对象,实现我们得之数据易工作,这个CursorWrapper实际上是贯彻了Cursor接口。我们询问得到到的Cursor其实是Cursor的援,而系统实际返回给我们的肯定是Cursor接口的一个实现类似的靶子实例,我们为此CursorWrapper包装这个实例,然后再下SimpleCursorAdapter将结果显示到列表上。

  更新操作相当给履行SQL的UPDATE语句,语法为:UPDATE  table_name  SET  ###col =###1
 WHERE  ###col  = ###2

db.executeSQL(String sql); 
db.executeSQL(String sql, Object[] bindArgs);//sql语句中使用占位符,然后第二个参数是实际的参数集 

  该次的界面设计比较简单,因为要就6被作用,所以在界面被独出6单按钮,每个按钮对承诺一律栽功能,这些按钮的功效依次为新建数据库,更新数据库的版,向数据库被插记录,更新数据库中之笔录,查询数据库中的记录,删除数据库中之笔录。其界面效果如下:

c.move(int offset); //以当前位置为参考,移动到指定行 
c.moveToFirst();  //移动到第一行 
c.moveToLast();   //移动到最后一行 
c.moveToPosition(int position); //移动到指定行 
c.moveToPrevious(); //移动到前一行 
c.moveToNext();   //移动到下一行 
c.isFirst();    //是否指向第一条 
c.isLast();   //是否指向最后一条 
c.isBeforeFirst(); //是否指向第一条之前 
c.isAfterLast();  //是否指向最后一条之后 
c.isNull(int columnIndex); //指定列是否为空(列基数为0) 
c.isClosed();    //游标是否已关闭 
c.getCount();    //总数据项数 
c.getPosition();  //返回当前游标所指向的行数 
c.getColumnIndex(String columnName);//返回某列名对应的列索引值 
c.getString(int columnIndex);  //返回当前行指定列的值 

  界面设计:

下面,我们就是以一个实例来教具体的用法,我们新建一个誉为吧db的类别,结构如下:

  该函数是相仿SQLiteDatabase中的一个函数,其功效是实践同一条SQL语句发号施令,这漫漫告句之始末就是欠函数的参数。因此参数sql需要符合SQL语法规则。

咱们获取数据库实例时使用了getWritableDatabase()方法,也许朋友等会面出疑点,在getWritableDatabase()和getReadableDatabase()中,你干什么选择前者作为整个应用之数据库实例呢?在此处自己想跟大家要分析一下顿时或多或少。
我们来拘禁一下SQLiteOpenHelper中之getReadableDatabase()方法:

  履新数据库内容:

以实施完毕上面的代码后,系统即会于/data/data/[PACKAGE_NAME]/databases目录下生成一个“test.db”的数据库文件,如图:

  如果要是于android中运用SQLite,一般要再行描绘一个像样,而该类继承一个android提供访问该数据库的助手类SQLiteOpenHelper。
本次实验中我们于src文件夹下新建一个接近,类名为DatabaseHelper,该类继承SQLiteOpenHelper类,而后续SQLiteOpenHelper类的接近必须产生好的构造函数,因此依mars老师的代码,在次中写了3独构造函数,这3个函数的界别是参数个数的不比,参数个数少之函数是因另外有参数都为固化了,且它都是显示或隐式调用了父类的构造函数,下面是SQLiteOpenHelper的构造函数。

现行的主流移动装备像android、iPhone等还下SQLite作为复杂数据的囤引擎,在我们吧移动设备支出应用程序时,也许将以及SQLite来囤积我们大量底多寡,所以我们虽待控制活动设备上的SQLite开发技巧。对于Android平台来说,系统放了增长的API来供开发人员操作SQLite,我们可轻松的到位对数据的存取。

  实验步骤同结果:

public synchronized SQLiteDatabase getWritableDatabase() { 
  if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) { 
    // 如果mDatabase不为空已打开并且不是只读模式 则返回该实例 
    return mDatabase; 
  } 

  if (mIsInitializing) { 
    throw new IllegalStateException("getWritableDatabase called recursively"); 
  } 

  // If we have a read-only database open, someone could be using it 
  // (though they shouldn't), which would cause a lock to be held on 
  // the file, and our attempts to open the database read-write would 
  // fail waiting for the file lock. To prevent that, we acquire the 
  // lock on the read-only database, which shuts out other users. 

  boolean success = false; 
  SQLiteDatabase db = null; 
  // 如果mDatabase不为空则加锁 阻止其他的操作 
  if (mDatabase != null) 
    mDatabase.lock(); 
  try { 
    mIsInitializing = true; 
    if (mName == null) { 
      db = SQLiteDatabase.create(null); 
    } else { 
      // 打开或创建数据库 
      db = mContext.openOrCreateDatabase(mName, 0, mFactory); 
    } 
    // 获取数据库版本(如果刚创建的数据库,版本为0) 
    int version = db.getVersion(); 
    // 比较版本(我们代码中的版本mNewVersion为1) 
    if (version != mNewVersion) { 
      db.beginTransaction();// 开始事务 
      try { 
        if (version == 0) { 
          // 执行我们的onCreate方法 
          onCreate(db); 
        } else { 
          // 如果我们应用升级了mNewVersion为2,而原版本为1则执行onUpgrade方法 
          onUpgrade(db, version, mNewVersion); 
        } 
        db.setVersion(mNewVersion);// 设置最新版本 
        db.setTransactionSuccessful();// 设置事务成功 
      } finally { 
        db.endTransaction();// 结束事务 
      } 
    } 

    onOpen(db); 
    success = true; 
    return db;// 返回可读写模式的数据库实例 
  } finally { 
    mIsInitializing = false; 
    if (success) { 
      // 打开成功 
      if (mDatabase != null) { 
        // 如果mDatabase有值则先关闭 
        try { 
          mDatabase.close(); 
        } catch (Exception e) { 
        } 
        mDatabase.unlock();// 解锁 
      } 
      mDatabase = db;// 赋值给mDatabase 
    } else { 
      // 打开失败的情况:解锁、关闭 
      if (mDatabase != null) 
        mDatabase.unlock(); 
      if (db != null) 
        db.close(); 
    } 
  } 
} 

  adb kill-server

老三:第一,建表时根据标准去开;第二,查询时用别名,例如:SELECT id AS
_id FROM person;第三,在CursorWrapper里做文章:

前言

面的代码中几近包括了多数的数据库操作;对于增长、更新与去来说,我们且足以以

  adb start-server

咱俩以DBManager构造方法中实例化DBHelper并收获一个SQLiteDatabase对象,作为一切应用的数据库实例;在累加多只Person信息经常,我们采取了事务处理,确保数据完整性;最后咱们提供了一个closeDB方法,释放数据库资源,这一个步骤在

  由这个可以看到,删除操作也是成之。

图片 6

  public void execSQL (String sql)

适使上面所陈述,数据库第一不好创时onCreate方法会受调用,我们得以尽创建表的语,当系统发现本变化之后,会调用onUpgrade方法,我们可执行修改表结构相当话语。

  图片 7

db.insert(String table, String nullColumnHack, ContentValues values); 
db.update(String table, Contentvalues values, String whereClause, String whereArgs); 
db.delete(String table, String whereClause, String whereArgs); 

        public void onClick(View v) {
            // TODO Auto-generated method stub
            DatabaseHelper database_helper = new
DatabaseHelper(MainActivity.this, “tornadomeet.db”);
            SQLiteDatabase db =
database_helper.getWritableDatabase();
           
//查询的语法,参数1吗表名;参数2为表中的列名;参数3呢而询问的列名;参数时为对应列的价值;该函数返回的是一个游标
            Cursor cursor = db.query(“user1”, new String[]{“id”,
“name”}, “id=?”, new String[]{“1”},  null, null, null);
            //遍历每一个记下
            while(cursor.moveToNext()) {
                String name =
cursor.getString(cursor.getColumnIndex(“name”));//返回列名为name的价值
                System.out.println(“query—->” + name);
            }
        }      
    }

CursorWrapper cursorWrapper = new CursorWrapper(c) { 
  @Override 
  public int getColumnIndexOrThrow(String columnName) throws IllegalArgumentException { 
    if (columnName.equals("_id")) { 
      return super.getColumnIndex("id"); 
    } 
    return super.getColumnIndexOrThrow(columnName); 
  } 
}; 

        public void onClick(View v) {
            // TODO Auto-generated method stub
            DatabaseHelper database_helper = new
DatabaseHelper(MainActivity.this, “tornadomeet.db”, 2);
            SQLiteDatabase db =
database_helper.getReadableDatabase();
        }       
    }

/** 
   * This method allows the activity to take care of managing the given 
   * {@link Cursor}'s lifecycle for you based on the activity's lifecycle. 
   * That is, when the activity is stopped it will automatically call 
   * {@link Cursor#deactivate} on the given Cursor, and when it is later restarted 
   * it will call {@link Cursor#requery} for you. When the activity is 
   * destroyed, all managed Cursors will be closed automatically. 
   * 
   * @param c The Cursor to be managed. 
   * 
   * @see #managedQuery(android.net.Uri , String[], String, String[], String) 
   * @see #stopManagingCursor 
   */ 

package com.example.sqlite_test;

末尾,让咱看一下什么样采取这些数据操作方法来显示数据,下面是MainActivity.Java的布局文件以及代码:

  查询操作:

package com.scott.db; 

import java.util.ArrayList; 
import java.util.List; 

import android.content.ContentValues; 
import android.content.Context; 
import android.database.Cursor; 
import android.database.sqlite.SQLiteDatabase; 

public class DBManager { 
  private DBHelper helper; 
  private SQLiteDatabase db; 

  public DBManager(Context context) { 
    helper = new DBHelper(context); 
    //因为getWritableDatabase内部调用了mContext.openOrCreateDatabase(mName, 0, mFactory); 
    //所以要确保context已初始化,我们可以把实例化DBManager的步骤放在Activity的onCreate里 
    db = helper.getWritableDatabase(); 
  } 

  /** 
   * add persons 
   * @param persons 
   */ 
  public void add(List<Person> persons) { 
    db.beginTransaction(); //开始事务 
    try { 
      for (Person person : persons) { 
        db.execSQL("INSERT INTO person VALUES(null, ?, ?, ?)", new Object[]{person.name, person.age, person.info}); 
      } 
      db.setTransactionSuccessful(); //设置事务成功完成 
    } finally { 
      db.endTransaction();  //结束事务 
    } 
  } 

  /** 
   * update person's age 
   * @param person 
   */ 
  public void updateAge(Person person) { 
    ContentValues cv = new ContentValues(); 
    cv.put("age", person.age); 
    db.update("person", cv, "name = ?", new String[]{person.name}); 
  } 

  /** 
   * delete old person 
   * @param person 
   */ 
  public void deleteOldPerson(Person person) { 
    db.delete("person", "age >= ?", new String[]{String.valueOf(person.age)}); 
  } 

  /** 
   * query all persons, return list 
   * @return List<Person> 
   */ 
  public List<Person> query() { 
    ArrayList<Person> persons = new ArrayList<Person>(); 
    Cursor c = queryTheCursor(); 
    while (c.moveToNext()) { 
      Person person = new Person(); 
      person._id = c.getInt(c.getColumnIndex("_id")); 
      person.name = c.getString(c.getColumnIndex("name")); 
      person.age = c.getInt(c.getColumnIndex("age")); 
      person.info = c.getString(c.getColumnIndex("info")); 
      persons.add(person); 
    } 
    c.close(); 
    return persons; 
  } 

  /** 
   * query all persons, return cursor 
   * @return Cursor 
   */ 
  public Cursor queryTheCursor() { 
    Cursor c = db.rawQuery("SELECT * FROM person", null); 
    return c; 
  } 

  /** 
   * close database 
   */ 
  public void closeDB() { 
    db.close(); 
  } 
} 

  public SQLiteOpenHelper (Context context, String name, SQLiteDatabase.CursorFactory factory, int
version)

而或许感兴趣之章:

  • Android
    SQLite数据库增删改查操作的利用详解
  • Android开发之SQLite的施用方法
  • Android使用SQLite数据库的简约实例
  • android创建数据库(SQLite)保存图片示例
  • 深入Android SQLite
    事务处理详解
  • Android–SQLite(增,删,改,查)操作实例代码
  • android中sqlite的仍规范查找的小例子

  可以见到这数据库来2只说明,且可看到就2独说明建立之sqlite语句,其中第一个代表android自带的,第二单象征我们新建的。

为便利我们面向对象的运用数据,我们修建一个Person类,对诺person表中的字段,如下:

继往开来输入指令select \ from
user1;*(注意这为凡当真的sqlite语句,所以在指令执行吃只要以分行结束)查询好建的数据库中之表user1,发现中什么内容还没。

  @Override 
  protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 

    //打开或创建test.db数据库 
    SQLiteDatabase db = openOrCreateDatabase("test.db", Context.MODE_PRIVATE, null); 
    db.execSQL("DROP TABLE IF EXISTS person"); 
    //创建person表 
    db.execSQL("CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age SMALLINT)"); 
    Person person = new Person(); 
    person.name = "john"; 
    person.age = 30; 
    //插入数据 
    db.execSQL("INSERT INTO person VALUES (NULL, ?, ?)", new Object[]{person.name, person.age}); 

    person.name = "david"; 
    person.age = 33; 
    //ContentValues以键值对的形式存放数据 
    ContentValues cv = new ContentValues(); 
    cv.put("name", person.name); 
    cv.put("age", person.age); 
    //插入ContentValues中的数据 
    db.insert("person", null, cv); 

    cv = new ContentValues(); 
    cv.put("age", 35); 
    //更新数据 
    db.update("person", cv, "name = ?", new String[]{"john"}); 

    Cursor c = db.rawQuery("SELECT * FROM person WHERE age >= ?", new String[]{"33"}); 
    while (c.moveToNext()) { 
      int _id = c.getInt(c.getColumnIndex("_id")); 
      String name = c.getString(c.getColumnIndex("name")); 
      int age = c.getInt(c.getColumnIndex("age")); 
      Log.i("db", "_id=>" + _id + ", name=>" + name + ", age=>" + age); 
    } 
    c.close(); 

    //删除数据 
    db.delete("person", "age < ?", new String[]{"35"}); 

    //关闭当前数据库 
    db.close(); 

    //删除test.db数据库 
//   deleteDatabase("test.db"); 
  } 

  图片 8 

每当getReadableDatabase()方法中,首先判断是否就存在数据库实例并且是开拓状态,如果是,则直返回该实例,否则试图拿走一个可读写模式的数据库实例,如果赶上磁盘空间已满等状态得到失败以来,再因为单独念模式打开数据库,获取数据库实例并回到,然后也mDatabase赋值为流行开辟的数据库实例。既然生或调用到getWritableDatabase()方法,我们将看一下了:

        public void onClick(View v) {
            // TODO Auto-generated method stub
            DatabaseHelper database_helper = new
DatabaseHelper(MainActivity.this, “tornadomeet.db”);
            SQLiteDatabase db =
database_helper.getWritableDatabase();
            ContentValues values = new ContentValues();
            values.put(“name”, “tornadomeet”);
           
//参数1也表名,参数2为更新后底价值,参数3表示满足条件的列名称,参数4呢该列名下的值
            db.update(“user1”, values, “id=?”, new String[]{“1”});
        }       
    }

脚我们先来拘禁一下DBHelper:

  配置好环境变量后,在cmd中输入adb shell进入linux
shell环境前,需要拿android模拟器打开(本文都是针对模拟器而言,并非真机)。如果开行好了模拟器,且输入adb
shell命令后出现error: device not
found
错提示,则好杀掉adb进程然后更启航该过程,在cmd中输入如下命令:

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
  android:orientation="vertical" 
  android:layout_width="fill_parent" 
  android:layout_height="fill_parent"> 
  <Button 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="add" 
    android:onClick="add"/> 
  <Button 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="update" 
    android:onClick="update"/> 
  <Button 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="delete" 
    android:onClick="delete"/> 
  <Button 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="query" 
    android:onClick="query"/> 
  <Button 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="queryTheCursor" 
    android:onClick="queryTheCursor"/> 
  <ListView 
    android:id="@+id/listView" 
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content"/> 
</LinearLayout> 


package com.scott.db; 

import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 

import android.app.Activity; 
import android.database.Cursor; 
import android.database.CursorWrapper; 
import android.os.Bundle; 
import android.view.View; 
import android.widget.ListView; 
import android.widget.SimpleAdapter; 
import android.widget.SimpleCursorAdapter; 


public class MainActivity extends Activity { 

  private DBManager mgr; 
  private ListView listView; 

  @Override 
  public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main); 
    listView = (ListView) findViewById(R.id.listView); 
    //初始化DBManager 
    mgr = new DBManager(this); 
  } 

  @Override 
  protected void onDestroy() { 
    super.onDestroy(); 
    //应用的最后一个Activity关闭时应释放DB 
    mgr.closeDB(); 
  } 

  public void add(View view) { 
    ArrayList<Person> persons = new ArrayList<Person>(); 

    Person person1 = new Person("Ella", 22, "lively girl"); 
    Person person2 = new Person("Jenny", 22, "beautiful girl"); 
    Person person3 = new Person("Jessica", 23, "sexy girl"); 
    Person person4 = new Person("Kelly", 23, "hot baby"); 
    Person person5 = new Person("Jane", 25, "a pretty woman"); 

    persons.add(person1); 
    persons.add(person2); 
    persons.add(person3); 
    persons.add(person4); 
    persons.add(person5); 

    mgr.add(persons); 
  } 

  public void update(View view) { 
    Person person = new Person(); 
    person.name = "Jane"; 
    person.age = 30; 
    mgr.updateAge(person); 
  } 

  public void delete(View view) { 
    Person person = new Person(); 
    person.age = 30; 
    mgr.deleteOldPerson(person); 
  } 

  public void query(View view) { 
    List<Person> persons = mgr.query(); 
    ArrayList<Map<String, String>> list = new ArrayList<Map<String, String>>(); 
    for (Person person : persons) { 
      HashMap<String, String> map = new HashMap<String, String>(); 
      map.put("name", person.name); 
      map.put("info", person.age + " years old, " + person.info); 
      list.add(map); 
    } 
    SimpleAdapter adapter = new SimpleAdapter(this, list, android.R.layout.simple_list_item_2, 
          new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2}); 
    listView.setAdapter(adapter); 
  } 

  public void queryTheCursor(View view) { 
    Cursor c = mgr.queryTheCursor(); 
    startManagingCursor(c); //托付给activity根据自己的生命周期去管理Cursor的生命周期 
    CursorWrapper cursorWrapper = new CursorWrapper(c) { 
      @Override 
      public String getString(int columnIndex) { 
        //将简介前加上年龄 
        if (getColumnName(columnIndex).equals("info")) { 
          int age = getInt(getColumnIndex("age")); 
          return age + " years old, " + super.getString(columnIndex); 
        } 
        return super.getString(columnIndex); 
      } 
    }; 
    //确保查询结果中有"_id"列 
    SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, android.R.layout.simple_list_item_2,  
        cursorWrapper, new String[]{"name", "info"}, new int[]{android.R.id.text1, android.R.id.text2}); 
    ListView listView = (ListView) findViewById(R.id.listView); 
    listView.setAdapter(adapter); 
  } 
} 

  第一独参数为此类本身;第二个参数为数据库的名;第3只参数是故来设置游标对象的,这里一般安装也null;参数四凡数据库的版本号。

除此之外统一之样式外,他们还有个别的操作方法:

    public class UpdateOnClickListener implements OnClickListener{

package com.scott.db; 

public class Person { 
  public int _id; 
  public String name; 
  public int age; 
  public String info; 

  public Person() { 
  } 

  public Person(String name, int age, String info) { 
    this.name = name; 
    this.age = age; 
    this.info = info; 
  } 
} 

  运行模拟器,单击create sqlite
database按钮,创建一个称也”tornadomeet”的数据库,版本号为1,这时候可以视程序终端显示”create
a sqlite database”字样。在cmd中输入如下命令:adb shell;cd data; cd data; ls; cd
com.example.sqlite_test;
ls;
命令,其中com.example.splite是依照程序的包名,输入最后ls命令后好看来有2独文本夹cache,
lib。然后以单击后持续ls命令查看,多了一个database文件夹。使用命令cd
database
入该文件夹后ls发现中来数据库,截图如下:

  ContentValues是用以数据库中存放数据的切近,也是以的键值对来存放数据的,有硌类似content和bundle等。该构造函数是建立一个默认大小的空的多寡集。

  单击模拟器的insert按钮,进入sqlite对应之数据库后,输入select \ from
user1;*命令后(带分号)可以看到有如下显示:1 |
tornado,说明我们的数据库成功插入了同等漫长记下,该记录之内容是在先后中静态给的。

每当该手续中,当照下update sqlite
database按钮后,我们当监听器函数中新建了一个数据库,数据库名吧”tornadomeet”不移,只是将那版本号设置为2。因为本号变了,所以程序会活动去调用SQLiteOpenHelper的子类的onUpgrade方法,该次中不过是于拖欠措施被输出一长长的语句而已。

    public class InsertOnClickListener implements OnClickListener{

        public void onClick(View v) {
            // TODO Auto-generated method stub
           
//创建一个DatabaseHelper类的目标,该类是独一个java文件,这里以2独参数的构造函数,建立之数码
            //库的讳吧tornadomeet.db
            DatabaseHelper database_helper = new
DatabaseHelper(MainActivity.this, “tornadomeet.db”);
           
//只有调用getReadableDatabase()或者getWriteableDatabase()函数后才能够回去一个SQLiteDatabase对象
            SQLiteDatabase db =
database_helper.getReadableDatabase();
        }               
    }

    public class CreateDatabaseOnClickListener implements
OnClickListener{

  查询操作使用SQLiteOpenHelper中的query方法,这里的询问是依赖仍列名name去查询的,实际查询过程被凡是来一个游标,开始经常对表头,后面同样坏同差为生转移,直到满足查询的口径时就是输出,然后终止查询。

    public class UpdateDatabaseOnClickListener implements
OnClickListener{

留下评论

网站地图xml地图