解析及SQLite

前端之家收集整理的这篇文章主要介绍了解析及SQLite前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

sharePreference

  • 非常适合保存零散数据

    1. SharedPreference ap =getSharedPreference("info",MODE_PRIVATE);
    2. String name = sp.getString("name","");
    3. String pass = sp.getString("pass","");
    4. sp.edit().putString("name","haha");
    5. et_name.setText(name);
    6. et_pass.setText(pass);
    7.  
    8. //使用
    9. String n =et_name.getText().toString();
    10. String p = et_pass.getText().toString();
    11. 通常用于应用简单的配置信息!!!打勾。很方便

    它是键值对保存形式,所以非常简单

Edit it= sp.edit();

ed.putString(“name”,name).commit();

ed.putString(“password”,password).commit();

使用XML序列化器生成xml文件

  1. //拿到序列化器生成xml对象
  2. XmlSerializer xs = Xml.serializer();
  3. //初始化
  4. FileOutputStream fos = new FileOutputStream("sdcard/sms.xml");
  5. //encoding:制定用什么编码生成xml文件
  6. xs.setOutput(fos,"utf-8");
  7. //开始生成xml文件,这个encoding:"utf-8"是xml头结点中的encoding的编码格式
  8. xs.startDocument("utf-8",true);
  9. xs.startTag(null,"message");
  10. xs.text(sms,"ssss");
  11. xs.endTag(null,"message");
  12. //告诉序列化器,文件生成完毕
  13. xs.endDocument();

pull解析

  1. //获取src文件夹下的资源文件
  2. InputStream is = getClassLoader().getResourceAsStream("weather.xml");
  3. //拿到pull解析器对象
  4. XmlPullParser xp = Xml.newPullParser();
  5. //初始化
  6. xp.setInput(is,"utf-8");
  7. //获取当前节点的事件类型,通过事件类型的判断,知道当前节点是何结点,从而确定我们应该做什么操作,每个类型结点都有一个固定的int值(0,1,2,3,4)
  8. int type = xp.getEventType();
  9. City city = null;
  10. //一直走,直到走到结束节点
  11. while(type !=XmlPullParser.END_DOCUMENT){
  12. //根据结点的类型,要做不同的操作
  13. switch(type){
  14. case ZXmlPullParser.START_TAG:
  15. if("weather".equals(xp.getName())){
  16. //创建city集合对象,用于存放city的javabean对象
  17. cityList = new ArrayList<City>();//全局声明
  18. }else if("city".equals(xp.getName())){
  19. //写一个city的javabean然后存储city的三个数据
  20. city = new City();//City city在成员变量处定义,这样可以全局引用
  21. }else id("name".equals(xp.getName())){
  22. //获取当前节点的下一个节点的文本
  23. String name = xp.nextText();
  24. city.setName(name);
  25. }else id("temp".equals(xp.getName())){
  26. //获取当前节点的下一个节点的文本
  27. String temp = xp.nextText();
  28. city.setTemp(temp);
  29. }else id("pm".equals(xp.getName())){
  30. //获取当前节点的下一个节点的文本
  31. String pm = xp.nextText();
  32. city.setPm(pm);
  33. }
  34. break;
  35. case ZXmlPullParser.END_TAG:
  36. if("city".equals(xp.getName())){
  37. //把city的javabean放入集合中
  38. cityList.add(city);
  39. }
  40. break;
  41. }
  42. //把指针移动到下一个节点,并返回该节点的事件类型
  43. type = xp.next();
  44. }
@H_301_27@测试
  • 了解即可,有专门测试人员

按岗位划分

  • 黑盒测试:测试逻辑业务(不懂代码的)
  • 白盒测试:测试逻辑方法(懂代码的)

按测试粒度分

  • 方法测试:function test
  • 单元测试:unit test(多个方法测试)
  • 集成测试:integration test(能否交换数据)
  • 系统测试:system test

按测试的暴力程度分

  • 冒烟测试:smoke test(高负荷运转)
  • 压力测试:pressure test(针对服务器测试:20万个访问量)

单元测试

  • junit
  • 定义一个类继承自AndroidTestCase
  • 需要在清单文件中定义指令集和类库(指令集只有一个)
    *

    1. <instrumentation
    2. //指令集
    3. androidname="android.test.InstrumentationTestRunner"
    4. //指定要测试的哪个项目
    5. androidtargetPackage="测试项目的包名"
    6. ></instrumentation>
    7. //以上是和<applaction>属于同级节点的,写在其上方即可
    8. -------------------------------------------------
    9. //类库只有一个,根据提示
    10. <user-library
    11. android:name="android.test.runner"
    12. ></user-library>
    13. //注意,它的位置是位于<applaction>节点内,属于其子节点,跟<activity>是属于同级节点

*在类中写一个test方法,对test选中,然后Run As–> Android Junit Test

  1. class myTest extends AndroidTestCase{
  2. public void test(){
  3. //写代码
  4. System.out.println("测试框架跑起来了");
  5. //断言:用来检测实际值与期望值是否一致
  6. assertEquals(期望值,实际值);
  7. }
  8. }
  9. //测一个方法一个test,下一个test2

sqlite 内置的数据库(安卓数据库

定义一个类,MyOpenHelper继承sqliteOpenHelper//打开帮助器

super(context,name,factory,version);//四个参数?

context:上下文;一般用MainActivity.this
||测试的时候用:getContext()获取虚拟的上下文;测试框架专用的

name:数据库名称

factory:游标工厂;父类是CursorFactory游标所在位置读取数据,移到下一行再读再移;通常传null,就是使用默认的游标工厂

verson:设置 数据库的版本号

重写两个方法:OnCreate():数据库创建时,此方法调用;OnUpgrade():数据库升级时,此方法调用

创建表

  1. //拿到序列化器生成xml对象
  2. db.execsql("create table person(_id integer primary key autoincrement,name char(10),salary char(20),phone integer(20))");

//主键是:_id;默认这样写,最好这样写;这个是创建一个person表,含有四个字段(id,姓名,工资,电话);id是主键,自增长!

db.execsql(“create table person(_id integer primary key autoincrement,phone integer(20))”);
//主键是:_id;默认这样写,最好这样写;这个是创建一个person表,含有四个字段(id,电话);id是主键,自增长!

sqlite:轻量级数据库,不检查数据类型;存入的都是字符串来保存的(所以不用定义类型,但定义类型是给程序员看的,用来表示它应该存储什么类型),但是定义好的类型,数据类型过于不一致,不会存储。

增加数据:insert();

  1. //创建一个对象
  2. MyOpenHelper oh = new MyOpenHelper(getContext(),"people.db",null,1);
  3. //获取数据库对象
  4. sqliteDatabase db = oh.getWritableDatabase();
  5. 例子:
  6. db.execsql("insert into person (name,salary,phone)values(?,?,?))",new Object[]{'小志','13000','13838383838'});
  7. db.close();
  8.  
  9. 上述?是占位符,后面对占位符进行填充。

删除数据 delete

  1. //创建一个对象
  2. MyOpenHelper oh = new MyOpenHelper(getContext(),1);
  3. //获取数据库对象
  4. sqliteDatabase db = oh.getWritableDatabase();
  5. db.execsql("delete from person");删除person所有数据
  6. db.execsql("delete from person where name= ?",new Object[]{"小志"});
  7.  
  8. db.close();

修改数据 update

  1. //创建一个对象
  2. MyOpenHelper oh = new MyOpenHelper(getContext(),1);
  3. //获取数据库对象
  4. sqliteDatabase db = oh.getWritableDatabase();
  5. db.execsql("update person set phone = ? where name = ?",new Object[]{18666,"小志的儿子"});
  6. db.close;

查询数据 select

  1. //创建一个对象
  2. MyOpenHelper oh = new MyOpenHelper(getContext(),1);
  3. //获取数据库对象
  4. sqliteDatabase db = oh.getWritableDatabase();
  5. Cursor cursor = db.rawQuery("select name,salary from person",null);
  6. //查询了两个字段,所以name索引是0,salary索引是1,索引和select name,salary顺序有关
  7. while(cursor.moveToNext()){
  8. //参数是要查询的数据的索引
  9. String name = cursor.getString(0);
  10. //上面写法有时容易混淆,所以还有一种方法查询name值,正式开发写下面这个
  11. //String name = cursor.getString(cursor.getColumnIndex("name"));
  12. String salary = cursor.getString(1);
  13. }

通过api来增删改(使用数据库代码进行增删改,不好调试,所以出现了api方法,线程封装好的方法)

  1. //把要插入的数据全部封装至ContentValues对象(第三个参数)
  2. ContentValues values = new ContentValues();//相当于map
  3. values.put("name","孙一一");
  4. values.put("phone","15999");
  5. values.put("salary",19999);
  6. db.insert("person",values);//第二个数据一般用不上,常写null
  7. //返回的是插入数据的行ID或者是主键;插入失败返回-1
  8.  
  9. //用api删除数据
  10. db.delete("person","name = ? and _id=?",new String[]{"小志的儿子",3});
  11. //删除成功返回的是删除的行数(删了几行数据),返回-1则删除失败
  12.  
  13. //用api修改数据
  14. ContentValues value = new ContentValues();
  15. value.put("salary",26000);//修改salary字段的值
  16. db.update("person",value,"name = ?",new String[]{"孙一一"});
  17. //返回值是被删除的行数,一行就是1,3行就是3;删除失败返回-1;
  18.  
  19. //用api查询query
  20. //db.query("person",new String[]{"name","salary"},);
  21. //查询所有字段
  22. Cursor cursor = db.query("person",null);
  23. while(curor.moveToNext()){
  24. String name = cursor.getString(cursor.getColumnIndex("name"));
  25. String phone = cursor.getString(cursor.getColumnIndex("phone"));
  26. String salary = cursor.getString(cursor.getColumnIndex("salary"));
  27. System.out.println(name+";"+phone+";"+salary);
  28. }

由上看出,api的增删改都封装在了ContentValues类名!

sqlite之事物

保证所有sql语句要么一起成功,要么一起失败!(银行转账,转出,转入)

  1. try{
  2. //开启事物
  3. db .beginTransaction();
  4. ContentValues values = new ContentValues();
  5. values.put("salary",13000);
  6. db.update("person",values,new String[]{"小志"});
  7. //values.clear();//有时会携带前面的数据
  8. values.put("salary",15000);
  9. db.update("person",new String[]{"小志的儿子"});
  10. //设置 事物执行成功
  11. db.setTransactionSuccessful();
  12. //关闭事物,同时提交,如果已经设置事物执行成功,那么sal语句就生效了,反之sql语句回滚。
  13. }
  14. finally{
  15. db.endTransaction();
  16. }

数据库的数据取出,显示在UI上

  1. List<person> personList = new ArrayList<Person>();
  2. //把数据库的数据查询处出来
  3. MyOpenHelper oh = new MyOpenHelper(this,1);
  4. sqliteDatabase db = oh.getWritableDatabase();
  5. Cursor cursor = db.query("perosn",null);
  6. //先写一个javabean,Person类
  7. while(cursor.moveToNext()){
  8. String _id = cuisor.getString(0);
  9. String name =cuisor.getString(1);
  10. String phone=cuisor.getString(2);
  11. String salary=cuisor.getString(3);
  12.  
  13. Person p = new Person(_id,phone,salary);
  14. personList.add(p);
  15. }
  16. ------------------------------------------------
  17. 查询:从第20行数据开始,读取到10条数据:最后一个null替换成要找的序列(开始位置,读取数据)
  18. Cursor cursor = db.query("perosn","20,10")

JSON解析的三种解析方式

  • JSON、GSON、FASTJSON

  • get()和opt()两种方法都可以通过index索引返回指定的数值,put()方法用来添加或者替换数值。同样这个类的value类型可以包括:Boolean、JSONArray、JSONObject、Number、String或者默认值JSONObject.NULL object。
    构建json文本;获取值;

    1. 案例:
    2. JSONObject,JSONArray来构建json文本
    3.  
    4. 1. // 首先最外层是{},是创建一个对象
    5. 2. JSONObject person = new JSONObject();
    6. 3. // 第一个键phone的值是数组,所以需要创建数组对象
    7. 4. JSONArray phone = new JSONArray();
    8. 5. phone.put("12345678").put("87654321");
    9. 6. person.put("phone",phone);
    10. 7.
    11. 8. person.put("name","yuanzhifei89");
    12. 9. person.put("age",100);
    13. 10. // 键address的值是对象,所以又要创建一个对象
    14. 11. JSONObject address = new JSONObject();
    15. 12. address.put("country","china");
    16. 13. address.put("province","jiangsu");
    17. 14. person.put("address",address);
    18. 15. person.put("married",false);
    19. 还可以使用JSONStringer来构建json文本
    20.  
    21. 1. JSONStringer jsonText = new JSONStringer();
    22. 2. // 首先是{,对象开始。object和endObject必须配对使用
    23. 3. jsonText.object();
    24. 4.
    25. 5. jsonText.key("phone");
    26. 6. // 键phone的值是数组。array和endArray必须配对使用
    27. 7. jsonText.array();
    28. 8. jsonText.value("12345678").value("87654321");
    29. 9. jsonText.endArray();
    30. 10.
    31. 11. jsonText.key("name");
    32. 12. jsonText.value("yuanzhifei89");
    33. 13. jsonText.key("age");
    34. 14. jsonText.value(100);
    35. 15.
    36. 16. jsonText.key("address");
    37. 17. // 键address的值是对象
    38. 18. jsonText.object();
    39. 19. jsonText.key("country");
    40. 20. jsonText.value("china");
    41. 21. jsonText.key("province");
    42. 22. jsonText.value("jiangsu");
    43. 23. jsonText.endObject();
    44. 24.
    45. 25. jsonText.key("married");
    46. 26. jsonText.value(false);
    47. 27.
    48. 28. // },对象结束
    49. 29. jsonText.endObject();
  • getType可以将要获取的键的值转换为指定的类型,如果无法转换或没有值则抛出JSONException

  • optType也是将要获取的键的值转换为指定的类型,无法转换或没有值时返回用户提供或这默认提供的值
    1. 1. // 所有使用的对象都是用上面创建的对象
    2. 2. // 将第一个电话号码转换为数值和将名字转换为数值
    3. 3. phone.getLong(0);
    4. 4. person.getLong("name"); // 会抛异常,因为名字无法转换为long
    5. 5. phone.optLong(0); // 代码内置的默认值
    6. 6. phone.optLong(0,1000); // 用户提供的默认值
    7. 7. person.optLong("name");
    8. 8. person.optLong("name",1000); // 不像上面那样抛异常,而是返回1000
    9. 9. } catch (JSONException ex) {
    10. 10. // 异常处理代码
    11. 11. }
  • json文本解析类JSONTokener

  • 按照RFC4627规范将json文本解析为相应的对象。
  • 对于将json文本解析为对象,只需要用到该类的两个api:
  • 构造函数 public Object nextValue();

猜你在找的Sqlite相关文章