Android学习笔记 - DOM SAX PULL JSON

最新推荐文章于 2024-08-14 11:20:14 发布

joker_wqz

最新推荐文章于 2024-08-14 11:20:14 发布

阅读量494

点赞数

分类专栏： Android 文章标签： android

Android 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Dom 创建 XML

Dom，借助 javax.xml.parsers.DocumentBuilder，可以创建 org.w3c.dom.Document 对象。

使用来自 DocumentBuilderFactory 的 DocumentBuilder 对象在 Android 设备上创建与解析 XML 文档。您将使用 XML pull 解析器的扩展来解析 XML 文档。

Code

[java]view plaincopyprint? 
   
 /** Dom方式，创建 XML  */  
 public String domCreateXML() {  
     String xmlWriter = null;  
       
     Person []persons = new Person[3];       // 创建节点Person对象  
     persons[0] = new Person(1, "sunboy_2050", "http://blog.csdn.net/sunboy_2050");  
     persons[1] = new Person(2, "baidu", "http://www.baidu.com");  
     persons[2] = new Person(3, "google", "http://www.google.com");  
       
     try {  
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();  
         DocumentBuilder builder = factory.newDocumentBuilder();  
         Document doc = builder.newDocument();  
           
         Element eleRoot = doc.createElement("root");  
         eleRoot.setAttribute("author", "homer");  
         eleRoot.setAttribute("date", "2012-04-26");  
         doc.appendChild(eleRoot);  
           
         int personsLen = persons.length;  
         for(int i=0; i<personsLen; i++) {  
             Element elePerson = doc.createElement("person");  
             eleRoot.appendChild(elePerson);  
               
             Element eleId = doc.createElement("id");  
             Node nodeId = doc.createTextNode(persons[i].getId() + "");  
             eleId.appendChild(nodeId);  
             elePerson.appendChild(eleId);  
   
             Element eleName = doc.createElement("name");  
             Node nodeName = doc.createTextNode(persons[i].getName());  
             eleName.appendChild(nodeName);  
             elePerson.appendChild(eleName);  
   
             Element eleBlog = doc.createElement("blog");  
             Node nodeBlog = doc.createTextNode(persons[i].getBlog());  
             eleBlog.appendChild(nodeBlog);  
             elePerson.appendChild(eleBlog);  
         }  
           
           
         Properties properties = new Properties();  
         properties.setProperty(OutputKeys.INDENT, "yes");  
         properties.setProperty(OutputKeys.MEDIA_TYPE, "xml");  
         properties.setProperty(OutputKeys.VERSION, "1.0");  
         properties.setProperty(OutputKeys.ENCODING, "utf-8");  
         properties.setProperty(OutputKeys.METHOD, "xml");  
         properties.setProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");  
           
         TransformerFactory transformerFactory = TransformerFactory.newInstance();  
         Transformer transformer = transformerFactory.newTransformer();  
         transformer.setOutputProperties(properties);  
           
         DOMSource domSource = new DOMSource(doc.getDocumentElement());  
         OutputStream output = new ByteArrayOutputStream();  
         StreamResult result = new StreamResult(output);  
         transformer.transform(domSource, result);  
           
         xmlWriter = output.toString();  
           
     } catch (ParserConfigurationException e) {      // factory.newDocumentBuilder  
         e.printStackTrace();  
     } catch (DOMException e) {                      // doc.createElement  
         e.printStackTrace();  
     } catch (TransformerFactoryConfigurationError e) {      // TransformerFactory.newInstance  
         e.printStackTrace();  
     } catch (TransformerConfigurationException e) {     // transformerFactory.newTransformer  
         e.printStackTrace();  
     } catch (TransformerException e) {              // transformer.transform  
         e.printStackTrace();  
     } catch (Exception e) {  
         e.printStackTrace();  
     }  
       
     savedXML(fileName, xmlWriter.toString());  
       
     return xmlWriter.toString();  
 }  

运行结果：

DOM解析XML文件时，会将XML文件的所有内容读取到内存中，然后允许您使用DOM API遍历XML树、检索所需的数据。使用DOM操作XML的代码看起来比较直观，并且，在某些方面比基于SAX的实现更加简单。但是，因为DOM需要将XML文件的所有内容读取到内存中，所以内存的消耗比较大，特别对于运行Android的移动设备来说，因为设备的资源比较宝贵，所以建议还是采用SAX来解析XML文件，当然，如果XML文件的内容比较小采用DOM是可行的。

Java代码

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* 使用Dom解析xml文件
*
*/
public class DomXMLReader {
public static List<Person> readXML(InputStream inStream) {
List<Person> persons = new ArrayList<Person>();
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
try {
DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(inStream);
Element root = dom.getDocumentElement();
NodeList items = root.getElementsByTagName("person");
//查找所有person节点
for (int i = 0; i < items.getLength(); i++) {
Person person = new Person();
//得到第一个person节点
Element personNode = (Element) items.item(i);
//获取person节点的id属性值
person.setId(new Integer(personNode.getAttribute("id")));
//获取person节点下的所有子节点(标签之间的空白节点和name/age元素)
NodeList childsNodes = personNode.getChildNodes();
for (int j = 0; j < childsNodes.getLength(); j++) {
Node node = (Node) childsNodes.item(j);
//判断是否为元素类型
if(node.getNodeType() == Node.ELEMENT_NODE){
Element childNode = (Element) node;
//判断是否name元素
if ("name".equals(childNode.getNodeName())) {
//获取name元素下Text节点,然后从Text节点获取数据 person.setName(childNode.getFirstChild().getNodeValue());
} else if (“age”.equals(childNode.getNodeName())) {
person.setAge(new Short(childNode.getFirstChild().getNodeValue()));
}
}
}
persons.add(person);
}
inStream.close();
} catch (Exception e) {
e.printStackTrace();
}
return persons;
}

3. Dom开发小技巧

1) 快速获得一个简单XML中的某项数据，改方法只适用于某个属性在DOM中只存在一个

Java代码

public static String getValByTagName(Document doc, String tagName) {
NodeList list = doc.getElementsByTagName(tagName);
if (list.getLength() > 0) {
Node node = list.item(0);
Node valNode = node.getFirstChild();
if (valNode != null) {
String val = valNode.getNodeValue();
return val;
}
}
return null;
}

2) 快速的将数据列表转换成对象列表

如上述基本使用中的XML例子，先建立一个和XML对应的类，属性名称必须与XML中的名称一致，如：

Java代码

public class Person(){
private String name;
private String age;
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(String age){
this.age = age;
}
public String getAge(){
return age;
}
}

然后采用映射机制

Java代码

NodeList nodeList = doc.getElementsByTagName("person");
int len = nodeList.getLength();
for (int i = 0; i < len; i++) {
Node node = nodeList.item(i);
Person bean = (Person) convertToBean(Person.class, node);
}
public static Object convertToBean(Class clazz, Node ele) {
Object object = null;
try {
object = clazz.newInstance();
Class[] parameterTypes = new Class[] { String.class };
NodeList list = ele.getChildNodes();
int len = list.getLength();
for (int i = 0; i < len; i++) {
try {
Node node = list.item(i);
String nodeName = node.getNodeName();
String nodeVal = "";
Node valueNode = node.getFirstChild();
if (valueNode != null) {
nodeVal = valueNode.getNodeValue();
}
Object[] arguments = new Object[] { nodeVal };
if (nodeName.length() > 0) {
String first = nodeName.substring(0, 1);
String last = nodeName.substring(1);
Method method = clazz.getMethod("set" + first.toUpperCase() + last, parameterTypes);
method.invoke(object, arguments);
} <li sty

使用sax方式解析

基础知识：

这种方式解析是一种基于事件驱动的api，有两个部分，解析器和事件处理器，解析器就是XMLReader接口，负责读取XML文档，和向事件处理器发送事件(也是事件源)，事件处理器ContentHandler接口，负责对发送的事件响应和进行XML文档处理。

下面是ContentHandler接口的常用方法

public abstract void characters (char[] ch, int start, int length)

这个方法来接收字符块通知，解析器通过这个方法来报告字符数据块，解析器为了提高解析效率把读到的所有字符串放到一个字符数组（ch）中，作为参数传递给character的方法中，如果想获取本次事件中读取到的字符数据，需要使用start和length属性。

public abstract void startDocument () 接收文档开始的通知

public abstract void endDocument () 接收文档结束的通知

public abstract void startElement (String uri, String localName, String qName, Attributes atts) 接收文档开始的标签

public abstract void endElement (String uri, String localName, String qName) 接收文档结束的标签

在一般使用中为了简化开发，在org.xml.sax.helpers提供了一个DefaultHandler类，它实现了ContentHandler的方法，我们只想继承DefaultHandler方法即可。

另外SAX解析器提供了一个工厂类：SAXParserFactory，SAX的解析类为SAXParser 可以调用它的parser方法进行解析。

看了些基础以后开始上代码吧（核心代码，下载代码在附件）

 1 public class SAXPraserHelper extends DefaultHandler {
 2 
 3     final int ITEM = 0x0005;
 4 
 5     List<channel> list;
 6     channel chann;
 7     int currentState = 0;
 8 
 9     public List<channel> getList() {
10         return list;
11     }
12 
13     /*
14      * 接口字符块通知
15 */
16     @Override
17     public void characters(char[] ch, int start, int length)
18             throws SAXException {
19         // TODO Auto-generated method stub
20 // super.characters(ch, start, length);
21         String theString = String.valueOf(ch, start, length);
22         if (currentState != 0) {
23             chann.setName(theString);
24             currentState = 0;
25         }
26         return;
27     }
28 
29     /*
30      * 接收文档结束通知
31 */
32     @Override
33     public void endDocument() throws SAXException {
34         // TODO Auto-generated method stub
35         super.endDocument();
36     }
37 
38     /*
39      * 接收标签结束通知
40 */
41     @Override
42     public void endElement(String uri, String localName, String qName)
43             throws SAXException {
44         // TODO Auto-generated method stub
45         if (localName.equals("item"))
46             list.add(chann);
47     }
48 
49     /*
50      * 文档开始通知
51 */
52     @Override
53     public void startDocument() throws SAXException {
54         // TODO Auto-generated method stub
55         list = new ArrayList<channel>();
56     }
57 
58     /*
59      * 标签开始通知
60 */
61     @Override
62     public void startElement(String uri, String localName, String qName,
63             Attributes attributes) throws SAXException {
64         // TODO Auto-generated method stub
65         chann = new channel();
66         if (localName.equals("item")) {
67             for (int i = 0; i < attributes.getLength(); i++) {
68                 if (attributes.getLocalName(i).equals("id")) {
69                     chann.setId(attributes.getValue(i));
70                 } else if (attributes.getLocalName(i).equals("url")) {
71                     chann.setUrl(attributes.getValue(i));
72                 }
73             }
74             currentState = ITEM;
75             return;
76         }
77         currentState = 0;
78         return;
79     }
80 }

 1 private List<channel> getChannelList() throws ParserConfigurationException, SAXException, IOException
 2     {
 3         //实例化一个SAXParserFactory对象
 4         SAXParserFactory factory=SAXParserFactory.newInstance();
 5         SAXParser parser;
 6         //实例化SAXParser对象，创建XMLReader对象，解析器
 7         parser=factory.newSAXParser();
 8         XMLReader xmlReader=parser.getXMLReader();
 9         //实例化handler，事件处理器
10         SAXPraserHelper helperHandler=new SAXPraserHelper();
11         //解析器注册事件
12         xmlReader.setContentHandler(helperHandler);
13         //读取文件流
14         InputStream stream=getResources().openRawResource(R.raw.channels);
15         InputSource is=new InputSource(stream);
16         //解析文件
17         xmlReader.parse(is);
18         return helperHandler.getList();
19     }

从第二部分代码，可以看出使用SAX解析XML的步骤：

1、实例化一个工厂SAXParserFactory

2、实例化SAXPraser对象，创建XMLReader 解析器

3、实例化handler，处理器

4、解析器注册一个事件

4、读取文件流

5、解析文件

上图为最终效果图。

代码结构示意图：

我们先来看看代码：

main.xml

[xhtml]view plaincopy 
   
 <?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"  
     >  
 <TextView  
     android:id="@+id/showBeauty"    
     android:layout_width="fill_parent"   
     android:layout_height="wrap_content"   
     />  
 </LinearLayout>  

Activity的代码

[java]view plaincopy 
   
 package cn.com.pulltest;  
   
 import java.io.InputStream;  
 import java.util.ArrayList;  
   
 import org.xmlpull.v1.XmlPullParser;  
 import org.xmlpull.v1.XmlPullParserFactory;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
 import android.util.Log;  
 import android.widget.TextView;  
   
 public class PullActivity extends Activity {  
     private String result = "";  
     private ArrayList<Beauty> beauties = new ArrayList();  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
         try {  
             // 以流的形式获取src目录下的xml文件（此文件的父亲文件夹必须是src）  
             InputStream InputStream =  this.getClass().getClassLoader().getResourceAsStream("beauties.xml");  
             // 获取一个XmlPullParser  
             XmlPullParserFactory xmlPullParserFactory = XmlPullParserFactory.newInstance();  
             XmlPullParser parser = xmlPullParserFactory.newPullParser();  
             // 设置输入流已经编码方式  
             parser.setInput(InputStream, "UTF-8");  
             // 获取当前的事件类型  
             int eventType = parser.getEventType();  
             Beauty beauty = null;  
             while(XmlPullParser.END_DOCUMENT!=eventType){  
                 String nodeName = parser.getName();  
                   
                 switch (eventType) {  
                 case XmlPullParser.START_TAG:  
                     if(nodeName.equals("beauty")){  
                         beauty = new Beauty();  
                     }  
                     if(nodeName.equals("name")){  
                         beauty.setName(parser.nextText());  
                     }  
                     if(nodeName.equals("age")){  
                         beauty.setAge(parser.nextText());  
                     }  
                     break;  
                   
                 case XmlPullParser.END_TAG:  
                     if(nodeName.equals("beauty")&&beauty!=null){  
                         beauties.add(beauty);  
                     }  
                       
                     break;  
                 default:  
                     break;  
                 }  
                 // 手动的触发下一个事件  
                 eventType = parser.next();  
                 Log.i("PullActivity", eventType+"");  
             }  
               
             for(Beauty beauty2 : beauties){  
                 result+="/n"+beauty2.toString();  
             }  
             //result = beauties.size()+"";  
             TextView textView = (TextView) findViewById(R.id.showBeauty);  
             textView.setText("最终结果: /n "+result);  
               
               
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
           
           
     }  
     /** 
      *  
      * @author chenzheng 
      * 这里使用内部类是为了效率考虑，内部类要比单独顶一个bean类更加的高效以及节约空间 
      * 
      */  
     private class Beauty{  
         String name;  
         String age;  
         public String getName() {  
             return name;  
         }  
         public void setName(String name) {  
             this.name = name;  
         }  
         public String getAge() {  
             return age;  
         }  
         public void setAge(String age) {  
             this.age = age;  
         }  
         @Override  
         public String toString() {  
             return "美女资料 [年龄=" + age + ", 姓名=" + name + "]";  
         }   
           
           
           
     }  
       
       
 }  

beauties.xml

[xhtml]view plaincopy 
   
 <?xml version="1.0" encoding="UTF-8"?>  
   
 <beauties>  
   
     <beauty>  
   
         <name>林志玲</name>  
   
         <age>28</age>  
   
     </beauty>  
   
     <beauty>  
   
         <name>杨幂</name>  
   
         <age>23</age>  
   
     </beauty>  
   
 </beauties>

这里的book.xml没有用到。

AndroidManifest.xml使用的是默认的。

运行，我们就可以看到了刚开始的那种结果了。

----------------------------------------------------------------------------------------

这里对xml进行解析时，需要注意的是，beauties.xml的位置，我们这里多添加了一个book.xml也是为了让大家明白，xml文件的确切位置应该是在src下,而不是src下的子文件夹下。

----------------------------------------------------------------------------------------

一般，我们使用java解析xml,主要还是有两种方式，一种方式是SAX解析，另一种是DOM解析。当然还有一系列的其他第三方解析API,如JDOM/DOM4J.他们各自有各自的优缺点。这里我们主要分析下最基础的两种解析方式，sax解析和dom解析。

两者依赖的解析机制是完全不同的。sax解析，依赖于事件触发机制，你可以认为我们在读取xml的时候，每遇到一个xml内容都会触发相应的事件，我们一行行的往下读，事件也自动的一个个的往下触发，一直到最终结束。代码中，我们则需要实现一个defaultHandler，来定义当xml读到什么内容时，进行什么样子的操作。sax解析，只能从文档头一直读到尾，中间不能停止也不能对文件进行修改。直到解析完了整个文档才会返回。

dom解析，则是通过在内存中形成一个节点树来完成xml解析，它虽然可以快速的定位xml中的某个位置，并且可以对其进行修改操作，但是它对内存的要求比较大。特别是当xml文件比较大的时候，这个缺点就更严重了。对于手机来说，这很致命。

SAX方式的特点是需要解析完整个文档才会返回，如果在一个XML文档中我们只需要前面一部分数据，但是使用SAX方式还是会对整个文档进行解析，尽管XML文档中后面的大部分数据我们其实都不需要解析，因此这样实际上就浪费了处理资源。

为了解决点这种缺陷，Android利用另一种更加高效方便的xml解析方式对xml文件进行解析，这就是Pull解析。

Pull解析器和SAX解析器虽有区别但也有相似性。他们的区别为：SAX解析器的工作方式是自动将事件推入注册的事件处理器进行处理，因此你不能控制事件的处理主动结束；而Pull解析器的工作方式允许你在应用程序代码中主动从解析器中获取事件，正因为是主动获取事件，因此可以在满足了需要的条件后不再获取事件，结束解析。

OPhone/Android系统中和Pull方式相关的包为org.xmlpull.v1，在这个包中提供了Pull解析器的工厂类XmlPullParserFactory和Pull解析器XmlPullParser，XmlPullParserFactory实例调用newPullParser方法创建XmlPullParser解析器实例，接着XmlPullParser实例就可以调用getEventType()和next()等方法依次主动提取事件，并根据提取的事件类型进行相应的逻辑处理。

代码如下

[java]view plaincopy 
   
 // 以流的形式获取src目录下的xml文件（此文件的父亲文件夹必须是src）  
             InputStream InputStream =  this.getClass().getClassLoader().getResourceAsStream("beauties.xml");  
             // 获取一个XmlPullParser  
             XmlPullParserFactory xmlPullParserFactory = XmlPullParserFactory.newInstance();  
             XmlPullParser parser = xmlPullParserFactory.newPullParser();  
             // 设置输入流已经编码方式  
             parser.setInput(InputStream, "UTF-8");  

我们然后就可以通过XmlPullParser里面提供的方法进行解析了，这里列出几个重要的方法说明

//在xml读取的开始调用，并触发读取文件时的第一个事件，返回的是事件的标示

public int getEventType() throws XmlPullParserException ；

//遍历下一个事件，返回一个事件的类型

public int next() throws XmlPullParserException, IOException

//得到当前Tag名字

public String getName()；

//获取文本

public String getText()；

//得到当前Tag下面的属性数量

public int getAttributeCount() ；

//得到当前Tag下面指定位置的属性名称

public String getAttributeName(int index)；

//得到当前Tag下面指定位置的属性植

public String getAttributeValue(int index);

//如果当前事件是一个start_tag并且下一个元素就是文本的话，那么就将这个文本内容返回；如果下一个元素直接就是end_tag的话，那么久返回空字符串；其他情况返回异常。

public String getNextText();

-------------------------------------------------------------------------

我们总结下pull解析的代码步骤：

第一步：我们需要先定义一个xml文件（当然也可以是从网络上获取的xml文件）

第二步：创建一个XmlPullParser对象，用于对文件进行解析

第三步：通过parser.setInput()方法，将文件和文件解析器关联起来。

第四步：调用getEventType();方法正式开始解析。

第五步：在while循环中处理xml

JSON是JavaScript Object Notation的缩写，可见JSON来源于JavaScript。JSON数据是一系列键值对的集合。

JSON和XML的比较

JSON比XML体积小
JSON和JavaScript交互更加方便
JSON对数据的描述性没有XML好
JSON的速度要远远大于XML
JSON的解析要比XML的解析要方便

JSON已经被大多数开发人员所接受，在网络数据的传输当中应用非常广泛

下面的代码就是一个JSON：

[plain]view plaincopy 
   
 {    
 "phone" : ["12345678", "87654321"], // 数组    
 "name" : "tianjiefeng", // 字符串    
 "age" : 100, // 数值    
 "address" : { "country" : "china", "province" : "jiangsu" }, // JSON对象    
 "married" : false // 布尔值    
 }  

JSON是以key/value的形式存在的，key是Strng类型的，value的类型可以是一个数组，可以是一个字符串，可以是一个数值，也可以是一个布尔值，甚至可以是一个JSON对象

一、JSONObject的创建

我们先来看一个Demo，把上面的JSON对象创建出来，并且写入存储卡文件

既然要写入存储卡，那么就必须在AndroidManifest.xml中加入一下权限

[html]view plaincopy 
   
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  

接着在JSONCreateDemoActivity.java里面编写如下代码：

[java]view plaincopy 
   
 package com.tianjf;  
   
 import java.io.File;  
 import java.io.FileNotFoundException;  
 import java.io.FileOutputStream;  
 import java.io.PrintStream;  
   
 import org.json.JSONArray;  
 import org.json.JSONException;  
 import org.json.JSONObject;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
 import android.os.Environment;  
   
 public class JSONCreateDemoActivity extends Activity {  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
   
         // 判断sdcard存不存在，不存在不操作  
         if (!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {  
             // 返回到程序的被调用出  
             return;  
         }  
   
         // 将JSON对象写入存储卡  
         writeJSONObjectToSdCard(createJSONObject());  
     }  
   
     // 创建以下的JSON对象  
     // {  
     // "phone" : ["12345678", "87654321"], // 数组  
     // "name" : "tianjiefeng", // 字符串  
     // "age" : 100, // 数值  
     // "address" : { "country" : "china", "province" : "jiangsu" }, // JSON对象  
     // "married" : false // 布尔值  
     // }  
     private JSONObject createJSONObject() {  
         // 最外层是｛｝，也就是一个JSONObject对象  
         JSONObject person = new JSONObject();  
         try {  
             // 第1个value是[ ]，也就是一个JSONArray对象  
             JSONArray phone = new JSONArray();  
             phone.put("12345678");  
             phone.put("87654321");  
             person.put("phone", phone);  
             // 第2个value一个字符串  
             person.put("name", "tianjiefeng");  
             // 第3个value一个字符串数值  
             person.put("age", 100);  
             // 第4个value一个JSONObject对象  
             JSONObject address = new JSONObject();  
             address.put("country", "china");  
             address.put("province", "jiangsu");  
             person.put("address", address);  
             // 第5个value一个布尔值  
             person.put("married", false);  
         } catch (JSONException e) {  
             e.printStackTrace();  
         }  
         return person;  
     }  
   
     /** 
      * 将JSON对象写入存储卡 
      *  
      * @param person 
      * @throws FileNotFoundException 
      */  
     private void writeJSONObjectToSdCard(JSONObject person) {  
         File file = new File(Environment.getExternalStorageDirectory() + File.separator + "json"  
                 + File.separator + "json.txt");  
         // 文件夹不存在的话，就创建文件夹  
         if (!file.getParentFile().exists()) {  
             file.getParentFile().mkdirs();  
         }  
         // 写入内存卡  
         PrintStream outputStream = null;  
         try {  
             outputStream = new PrintStream(new FileOutputStream(file));  
             outputStream.print(person.toString());  
         } catch (FileNotFoundException e) {  
             e.printStackTrace();  
         } finally {  
             if (outputStream != null) {  
                 outputStream.close();  
             }  
         }  
     }  
 }  

运行一下，打开File Explorer视图，打开mnt - sdcard - json目录，将里面的json.txt导出到计算机里面，就可以看到JSON对象以字符串的形式成功写入到了json.txt文件中

二、JSONObject的解析

直接将字符串转化为JSONObject对象来解析的Demo

[java]view plaincopy 
   
 package com.tianjf;  
   
 import java.util.HashMap;  
 import java.util.Map;  
   
 import org.json.JSONException;  
 import org.json.JSONObject;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
 import android.util.Log;  
   
 public class JSONParseDemoActivity extends Activity {  
   
     private static final String JSONString = "{" + "\"phone\":[\"12345678\",\"87654321\"],"  
             + "\"name\":\"tianjiefeng\"," + "\"age\":100,"  
             + "\"address\":{\"country\":\"china\",\"province\":\"jiangsu\"},"  
             + "\"married\":false" + "}";  
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
   
         // 解析得到一个Map对象  
         Map<String, Object> personMap = parseJSONString(JSONString);  
         Log.d("debug",  
                 "phone:" + personMap.get("phone") + "\n" + "name:" + personMap.get("name") + "\n"  
                         + "age:" + personMap.get("age") + "\n" + "address:"  
                         + personMap.get("address") + "\n" + "married:" + personMap.get("married"));  
     }  
   
     /** 
      * JSON解析 
      *  
      * @param JSONString 
      * @return 
      */  
     private Map<String, Object> parseJSONString(String JSONString) {  
         Map<String, Object> resultMap = new HashMap<String, Object>();  
         try {  
             // 直接把JSON字符串转化为一个JSONObject对象  
             JSONObject person = new JSONObject(JSONString);  
             // 第1个键值对  
             resultMap.put("phone", person.getJSONArray("phone").toString());  
             // 第2个键值对  
             resultMap.put("name", person.getString("name"));  
             // 第3个键值对  
             resultMap.put("age", person.getInt("age"));  
             // 第4个键值对  
             resultMap.put("address", person.getJSONObject("address").toString());  
             // 第5个键值对  
             resultMap.put("married", person.getBoolean("married"));  
         } catch (JSONException e) {  
             e.printStackTrace();  
         }  
         return resultMap;  
     }  
 }  

运行之后打印出来的Log如下

用JsonReader来读取JSON字符串的内容

打开Android帮助文档找到JsonReader，会发现Since: API Level 11（3.0），也就是说3.0之前的SDK是没有JsonReader的。如果要对应3.0之前的版本，可以到Google的网站上去下载gson的jar包（URL：http://code.google.com/p/google-gson/downloads/list）。jar包导入项目的流程如下：

新建libs文件夹，把下载的jar包添加到libs文件夹中
右键gson-1.6.jar --> Build Path --> Add to Build Path（add操作之后就会看到Package视图下的Referenced Libraries下多了个gson-1.6.jar，说明jar包添加成功）

添加好了jar包，我们就可以使用JsonReader了。具体代码如下

JSONUtils.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 import java.io.StringReader;  
   
 import com.google.gson.stream.JsonReader;  
   
 public class JSONUtils {  
     public void parseJson(String jsonData) {  
         try {  
             // 如果需要解析JSON数据，首要要生成一个JsonReader对象  
             JsonReader reader = new JsonReader(new StringReader(jsonData));  
             // 开始解析数组  
             reader.beginArray();  
             // 判断数组里面还有没下一个JSONObject对象  
             while (reader.hasNext()) {  
                 // 开始解析对象  
                 reader.beginObject();  
                 // 判断当前JSONObject对象里面还有没下一个键值对  
                 while (reader.hasNext()) {  
                     // 取出当前键值对的key  
                     String tagName = reader.nextName();  
                     // 取出key所对应的value  
                     if (tagName.equals("name")) {  
                         System.out.println("name--->" + reader.nextString());  
                     } else if (tagName.equals("age")) {  
                         System.out.println("age--->" + reader.nextInt());  
                     }  
                 }  
                 // 结束解析对象  
                 reader.endObject();  
             }  
             // 结束解析数组  
             reader.endArray();  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
 }  

JSONParseDemoActivity.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
   
 public class JSONParseDemoActivity extends Activity {  
   
     private static final String JSONString = "[{\"name\":\"Michael\",\"age\":20},{\"name\":\"Mike\",\"age\":21}]";  
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
   
         JSONUtils jsonUtils = new JSONUtils();  
         jsonUtils.parseJson(JSONString);  
     }  
 }  

这个例子是解析[{"name":"Michael","age":20},{"name":"Mike","age":21}]这个JSON字符串

先分析一下这个JSON字符串的结构：一个JSONArray里面有两个JSONObject

再分析一下JsonReader解析这个JSON字符串的流程：

遇到【[】，开始解析数组（reader.beginArray()）
遇到【{】，开始解析对象（reader.beginObject()）
遇到【"】，开始解析第一个键值对
遇到【"】，开始解析第二个键值对
遇到【}】，结束解析对象（reader.endObject()）
遇到【{】，开始解析对象（reader.beginObject()）
遇到【"】，开始解析第一个键值对
遇到【"】，开始解析第二个键值对
遇到【}】，结束解析对象（reader.endObject()）
遇到【]】，结束解析数组（reader.endArray()）

Gson类的fromJson方法自动解析并自动得到一个Entity对象，代码如下

User.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 public class User {  
     private String name ;  
     private int age ;  
     public String getName() {  
         return name;  
     }  
     public void setName(String name) {  
         this.name = name;  
     }  
     public int getAge() {  
         return age;  
     }  
     public void setAge(int age) {  
         this.age = age;  
     }  
 }  

JSONUtils.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 import com.google.gson.Gson;  
   
 public class JSONUtils {  
     public void parseUserFromJson(String jsonData) {  
         Gson gson = new Gson();  
         // Gson的fromJson方法是一 一对应的关系，自动将JSON的数据匹配到User对象中  
         User user = gson.fromJson(jsonData, User.class);  
         System.out.println("name--->" + user.getName());  
         System.out.println("age---->" + user.getAge());  
     }  
 }  

JSONParseDemoActivity.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
   
 public class JSONParseDemoActivity extends Activity {  
   
     private static final String JSONString = "{\"name\":\"Michael\",\"age\":20}";  
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
   
         JSONUtils jsonUtils = new JSONUtils();  
         jsonUtils.parseUserFromJson(JSONString);  
     }  
 }  

上面的例子只有一个JSONObject对象，如果有多个对象怎么做到直接映射到一个User的List里面呢？代码如下

User.java

同上

JSONUtils.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 import java.lang.reflect.Type;  
 import java.util.Iterator;  
 import java.util.LinkedList;  
   
 import com.google.gson.Gson;  
 import com.google.gson.reflect.TypeToken;  
   
 public class JSONUtils {  
     public void parseUserFromJson(String jsonData) {  
         Type listType = new TypeToken<LinkedList<User>>() {}.getType();  
         Gson gson = new Gson();  
         LinkedList<User> users = gson.fromJson(jsonData, listType);  
         Iterator<User> iterator = users.iterator();  
         while (iterator.hasNext()) {  
             User user = (User) iterator.next();  
             System.out.println("name--->" + user.getName());  
             System.out.println("age---->" + user.getAge());  
         }  
     }  
 }  

JSONParseDemoActivity.java

[java]view plaincopy 
   
 package com.tianjf;  
   
 import android.app.Activity;  
 import android.os.Bundle;  
   
 public class JSONParseDemoActivity extends Activity {  
   
     private static final String JSONString = "[{\"name\":\"Michael\",\"age\":20},{\"name\":\"Mike\",\"age\":21}]";  
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
   
         JSONUtils jsonUtils = new JSONUtils();  
         jsonUtils.parseUserFromJson(JSONString);  
     }  
 }  

joker_wqz

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android学习笔记 - DOM SAX PULL JSON

Dom 创建 XMLDom，借助 javax.xml.parsers.DocumentBuilder，可以创建 org.w3c.dom.Document 对象。使用来自 DocumentBuilderFactory 的 DocumentBuilder 对象在 Android 设备上创建与解析 XML 文档。您将使用 XML pull 解析器的扩展来解析 XML 文档。
复制链接

扫一扫

专栏目录