Android：解析XML的三种方式

最新推荐文章于 2023-07-26 20:04:43 发布
最新推荐文章于 2023-07-26 20:04:43 发布
阅读量266 收藏 1
点赞数 1
分类专栏： Android

1、首先，在布局文件中写一个Button控件和用来展示数据的ListView控件。

<Button  
    android:layout_width="wrap_content"  
    android:layout_height="wrap_content"  
    android:text="获取XML"  
    android:onClick="getdata"/>  

    <ListView  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:id="@+id/lv_main_data">  
    </ListView>

2、新建一个布局文件，用于listview展示数据，在这个布局文件中增加你要显示数据的TextView控件。代码如下：

<TextView  
       android:layout_width="0dp"  
       android:layout_height="wrap_content"  
       android:layout_weight="1"  
       android:textAppearance="?android:attr/textAppearanceLarge"  
       android:text="dfd"  
       android:id="@+id/tv_listview_one"  

       />  
   <TextView  
       android:layout_width="0dp"  
       android:layout_height="wrap_content"  
       android:layout_weight="1"  
       android:textAppearance="?android:attr/textAppearanceLarge"  
       android:text="dfd"  
       android:id="@+id/tv_listview_two"  

       />  
   <TextView  
   android:layout_width="0dp"  
   android:layout_height="wrap_content"  
   android:layout_weight="1"  
   android:textAppearance="?android:attr/textAppearanceLarge"  
   android:text="dfd"  
   android:id="@+id/tv_listview_three"  

   />

然后在MainActivity.java通过解析XML拿到数据。解析XML有三种方法，方法如下：

一、DOM解析器

  DOM(Document Object Model)：是一种用于XML文档的对象模型，直接访问XML文档中所有部分。

 特点：解析速度快，一次性解析整个文档。加载大文件时候效率低。代码如下:

public class MainActivity extends AppCompatActivity {  
    private ListView lv_main_data;  
    private ProgressDialog pd;  
    private List<UserEntity> lists = new ArrayList<>();  
    private MainActivity.myadapter myadapter;  
    String currentTag=null;  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        lv_main_data = (ListView) findViewById(R.id.lv_main_data);//拿到listview的ID  
        myadapter = new myadapter();  
        lv_main_data.setAdapter(myadapter);  
        pd = new ProgressDialog(this);//动画加载中  
        pd.setMessage("locaging.....");  
    }  
    class myadapter extends BaseAdapter{  

        @Override  
        public int getCount() {  
            return lists.size();  
        }  
        @Override  
        public Object getItem(int position) {  
            return lists.get(position);  
        }  
        @Override  
        public long getItemId(int position) {  
            return position;  
        }  
        @Override  
        public View getView(int position, View convertView, ViewGroup parent) {  
              if (convertView==null){  
                  convertView= LayoutInflater.from(MainActivity.this).inflate(R.layout.dom_listview,null);  
                  DomActivity activity=new DomActivity();  
                  activity.uname= (TextView) convertView.findViewById(R.id.tv_listview_one);  
                  activity.content= (TextView) convertView.findViewById(R.id.tv_listview_two);  
                  activity.anthour= (TextView) convertView.findViewById(R.id.tv_listview_three);  
                  convertView.setTag(activity);  
              }  
            DomActivity domActivity= (DomActivity) convertView.getTag();  
            domActivity.uname.setText(lists.get(position).getUname());  
            domActivity.content.setText(lists.get(position).getContent());  
            domActivity.anthour.setText(lists.get(position).getAnthour());  
            return convertView;  
        }  
    }  
//获取xml数据  
    public void getdata(View view){  
      new mytask().execute();  
        pd.show();  
    }  
    //写一个继承AsyncTask，重写它的两个方法  
    // 1、获取网络数据：doInBackground  
    // 2、更新UI（数据）：onPostExecute  
    class mytask extends AsyncTask{  

        private UserEntity userEntity;  
        private UserEntity userEntity1;  

        @Override  
        protected Object doInBackground(Object[] params) {  
            final List<UserEntity> list = new ArrayList<>();  

            //获取网络数据：定义获取网络数据的路径  
            String path="http://192.168.43.143:8080/android/android_xml.xhtml";  
            try {  
                URL url=new URL(path);//实例化url：将获取网络数据的路径放到URL中。  
                HttpURLConnection httpURLConnection= (HttpURLConnection) url.openConnection();//获取连接的对象  
                httpURLConnection.setRequestMethod("GET");//设置请求的方式：1、get；2、post  
                httpURLConnection.setConnectTimeout(5000);//请求连接超时的时间  
                int code=httpURLConnection.getResponseCode(); //获取响应码的值  
                if (code==200){//判断：如果响应码等于200时，获取返回过来的是XML数据  
                    //通过流的形式读取  
                    InputStream inputStream=httpURLConnection.getInputStream();  
                    //测试：是否拿到值  
                    String str=null;  
                    //字符流  
//                    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));//把字符流转成字节流  
//                    while ((str=bufferedReader.readLine())!=null){  
//                        Log.i("test", "doInBackground: ");}  

                    // 解析XML：  1、DOM  2、SAX  3、PULL  

                    //  一、使用DOM解析  
                     try {  
                       //  1、使用DOM解析:特点：一次性解析整个文档  
                        //  （工厂模式就是单列模式 只要有newInstance就是单列模式）  
                        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();//创建工厂构建器，再拿DOM解析器  
                        DocumentBuilder builder=factory.newDocumentBuilder();//创建document的构建器,通过工厂拿到DOM解析器  
                        Document document=builder.parse(inputStream);//解析数流：通过解析器拿到数流  
                        //DOM解析的原理：1、获取文档的标签(跟标签)  
                        Element root=document.getDocumentElement();  
                        Log.i("test", "doInBackground: "+root.getTagName());  
                          //2、获取文档的标签下所有的子节点  
                        NodeList node=root.getElementsByTagName("fq");//获取节点  
                        for (int i = 0; i <node.getLength() ; i++) {  
                            Element element= (Element) node.item(i);  
                            //3、获取节点下的属性  
                            String name=element.getAttribute("name");  
                            Log.i("test", "doInBackground: "+name);  
                            //4、获取子标签(拿标签的值)  
                            Element element1= (Element) element.getElementsByTagName("content").item(0);  
                            String content=element1.getTextContent();  
                            Element element2= (Element) element.getElementsByTagName("anthour").item(0);  
                            String anthour=element2.getTextContent();  
                            Log.i("test", "doInBackground: "+content+" ; "+anthour);  
                            UserEntity ue=new UserEntity(name,content,anthour);  
                            list.add(ue);  
                    }  
                    } catch (ParserConfigurationException e) {  
                        e.printStackTrace();  
                    } catch (SAXException e) {  
                        e.printStackTrace();  
                    }  

                }  
            } catch (MalformedURLException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            return list;  
        }  
        @Override//更新UI（数据）  
        protected void onPostExecute(Object o) {  
            super.onPostExecute(o);  
            List<UserEntity> list= (List<UserEntity>) o;  
            lists.addAll(list);  
            myadapter.notifyDataSetChanged();  
            pd.cancel();  
        }  
    }  
}

二、SAX解析器

    SAX(Simple API XML):使用流的形式处理，是一种以基于事件（方法）为驱动的解析器。

   特点：边读边解析，解析速度快，占用内存少，同时sax解析提供了很多方法：开始、结束标签；开始、结束文档；文本的方法。代码如下：

public class MainActivity extends AppCompatActivity {  

    private ListView lv_main_data;  
    private ProgressDialog pd;  
    private List<UserEntity> lists = new ArrayList<>();  
    private MainActivity.myadapter myadapter;  
    String currentTag=null;  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        lv_main_data = (ListView) findViewById(R.id.lv_main_data);//拿到listview的ID  
        myadapter = new myadapter();  
        lv_main_data.setAdapter(myadapter);  
        pd = new ProgressDialog(this);//动画加载中  
        pd.setMessage("locaging.....");  
    }  
    class myadapter extends BaseAdapter{  

        @Override  
        public int getCount() {  
            return lists.size();  
        }  
        @Override  
        public Object getItem(int position) {  
            return lists.get(position);  
        }  
        @Override  
        public long getItemId(int position) {  
            return position;  
        }  
        @Override  
        public View getView(int position, View convertView, ViewGroup parent) {  
              if (convertView==null){  
                  convertView= LayoutInflater.from(MainActivity.this).inflate(R.layout.dom_listview,null);  
                  DomActivity activity=new DomActivity();  
                  activity.uname= (TextView) convertView.findViewById(R.id.tv_listview_one);  
                  activity.content= (TextView) convertView.findViewById(R.id.tv_listview_two);  
                  activity.anthour= (TextView) convertView.findViewById(R.id.tv_listview_three);  
                  convertView.setTag(activity);  
              }  
            DomActivity domActivity= (DomActivity) convertView.getTag();  
            domActivity.uname.setText(lists.get(position).getUname());  
            domActivity.content.setText(lists.get(position).getContent());  
            domActivity.anthour.setText(lists.get(position).getAnthour());  
            return convertView;  
        }  
    }  
//获取xml数据  
    public void getdata(View view){  
      new mytask().execute();  
        pd.show();  
    }  
    //写一个继承AsyncTask，重写它的两个方法  
    // 1、获取网络数据：doInBackground  
    // 2、更新UI（数据）：onPostExecute  
    class mytask extends AsyncTask{  

        private UserEntity userEntity;  
        private UserEntity userEntity1;  

        @Override  
        protected Object doInBackground(Object[] params) {  
            final List<UserEntity> list = new ArrayList<>();  

            //获取网络数据：定义获取网络数据的路径  
            String path="http://192.168.43.143:8080/android/android_xml.xhtml";  
            try {  
                URL url=new URL(path);//实例化url：将获取网络数据的路径放到URL中。  
                HttpURLConnection httpURLConnection= (HttpURLConnection) url.openConnection();//获取连接的对象  
                httpURLConnection.setRequestMethod("GET");//设置请求的方式：1、get；2、post  
                httpURLConnection.setConnectTimeout(5000);//请求连接超时的时间  
                int code=httpURLConnection.getResponseCode(); //获取响应码的值  
                if (code==200){//判断：如果响应码等于200时，获取返回过来的是XML数据  
                    //通过流的形式读取  
                    InputStream inputStream=httpURLConnection.getInputStream();  
                    //测试：是否拿到值  
                    String str=null;  

                    // 解析XML：  1、DOM  2、SAX  3、PULL  

                  //  二;使用sax解析  
                    try {  
                        //1、使用SAX解析：特点：边读边解析，基于事件（方法）驱动  
                        // sax解析提供了很多的方法：开始标签 开始文档的方法，结束标签 结束文档的方法 文本  
                        //创建sax工厂模式，通过工厂拿到解析器（和DOM解析一样）  
                        SAXParserFactory parserFactory=SAXParserFactory.newInstance();//创建sax工厂  
                        SAXParser saxParser=parserFactory.newSAXParser();//拿到解析器  
                        saxParser.parse(inputStream,new DefaultHandler(){//实现sax解析的方法  
                            //开始文档的方法  
                            @Override  
                            public void startDocument() throws SAXException {  
                                super.startDocument();  
                            }  
                            //结束文档的方法  
                            @Override  
                            public void endDocument() throws SAXException {  
                                super.endDocument();  
                            }  
                            //开始标签的方法  
                            @Override  
                            public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {  
                                //1、拿到开始标签的名字：在DOM解析中，使用element拿到开始标签的名字。在sax解析中开始标签方法已经拿到了开始标签的名字  
                                super.startElement(uri, localName, qName, attributes);  
                                //2、拿到名字进行判断  
                                currentTag=localName;  
                                if ("fq".equals(localName)){//如果拿到的开始标签的名字是fq  
                                    //实列化对象  
                                    userEntity = new UserEntity();  
                                  //通过attributes拿属性的值.attributes多个属性的值  
                                    String name=attributes.getValue(0);  
                                    userEntity.setUname(name);//通过对象拿到标签属性的名字  
                                }  
                            }  
                            //结束标签的方法  
                            @Override  
                            public void endElement(String uri, String localName, String qName) throws SAXException {  
                                super.endElement(uri, localName, qName);  
                                currentTag=null;  
                                if ("fq".equals( localName)){  
                                    list.add(userEntity);  
                                }  
                            }  
                            //字符的方法  
                            @Override  
                            public void characters(char[] ch, int start, int length) throws SAXException {  
                                super.characters(ch, start, length);  
                                if ("content".equals(currentTag)){  
                                    String content=new String(ch, start, length);  
                                    userEntity.setContent(content);  
                                }else if ("anthour".equals(currentTag)){  
                                    String anthour=new String(ch, start, length);  
                                    userEntity.setAnthour(anthour);  
                                }  
                            }  
                        });  
                    } catch (ParserConfigurationException e) {  
                        e.printStackTrace();  
                    } catch (SAXException e) {  
                        e.printStackTrace();  
                    }  
                }  
            } catch (MalformedURLException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            return list;  
        }  
        @Override//更新UI（数据）  
        protected void onPostExecute(Object o) {  
            super.onPostExecute(o);  
            List<UserEntity> list= (List<UserEntity>) o;  
            lists.addAll(list);  
            myadapter.notifyDataSetChanged();  
            pd.cancel();  
        }  
    }}

三、PULL解析器

  Pull解析器与SAX解析器性质类似，都是基于事件处理模式。不同的是用法：Pull解析器需要自己获取事件后做出相当于的操作，pull是用于Android，用于Java中需要导入pull解析依赖包。

特点：解析速度快、使用方便、效率高。代码如下：

public class MainActivity extends AppCompatActivity {  

    private ListView lv_main_data;  
    private ProgressDialog pd;  
    private List<UserEntity> lists = new ArrayList<>();  
    private MainActivity.myadapter myadapter;  
    String currentTag=null;  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        lv_main_data = (ListView) findViewById(R.id.lv_main_data);//拿到listview的ID  
        myadapter = new myadapter();//实列化方法  
        lv_main_data.setAdapter(myadapter);//给listview一个适配器  
        pd = new ProgressDialog(this);//动画加载中  
        pd.setMessage("locaging.....");  
    }  
    class myadapter extends BaseAdapter{//写一个类继承baseadapter，重写它的方法  

        @Override  
        public int getCount() {//获取集合数量  
            return lists.size();  
        }  
        @Override  
        public Object getItem(int position) {//获取当前集合  
            return lists.get(position);  
        }  
        @Override  
        public long getItemId(int position) {//获取当前位置  
            return position;  
        }  
        @Override  
        public View getView(int position, View convertView, ViewGroup parent) {  
              if (convertView==null){  
                  convertView= LayoutInflater.from(MainActivity.this).inflate(R.layout.dom_listview,null);  
                  DomActivity activity=new DomActivity();//实列化对象  
                  activity.uname= (TextView) convertView.findViewById(R.id.tv_listview_one);//将每个属性增加到每个控件ID中  
                  activity.content= (TextView) convertView.findViewById(R.id.tv_listview_two);  
                  activity.anthour= (TextView) convertView.findViewById(R.id.tv_listview_three);  
                  convertView.setTag(activity);//获取标签的属性  
              }  
            DomActivity domActivity= (DomActivity) convertView.getTag();//得到标签  
            domActivity.uname.setText(lists.get(position).getUname());//通过标签得到值  
            domActivity.content.setText(lists.get(position).getContent());  
            domActivity.anthour.setText(lists.get(position).getAnthour());  
            return convertView;  
        }  
    }  
//获取xml数据  
    public void getdata(View view){  
      new mytask().execute();  
        pd.show();//画面展示  
    }  
    //写一个继承AsyncTask，重写它的两个方法  
    // 1、获取网络数据：doInBackground  
    // 2、更新UI（数据）：onPostExecute  
    class mytask extends AsyncTask{  

        private UserEntity userEntity;  
        private UserEntity userEntity1;  

        @Override  
        protected Object doInBackground(Object[] params) {  
            final List<UserEntity> list = new ArrayList<>();  

            //获取网络数据：定义获取网络数据的路径  
            String path="http://192.168.43.143:8080/android/android_xml.xhtml";  
            try {  
                URL url=new URL(path);//实例化url：将获取网络数据的路径放到URL中。  
                HttpURLConnection httpURLConnection= (HttpURLConnection) url.openConnection();//获取连接的对象  
                httpURLConnection.setRequestMethod("GET");//设置请求的方式：1、get；2、post  
                httpURLConnection.setConnectTimeout(5000);//请求连接超时的时间  
                int code=httpURLConnection.getResponseCode(); //获取响应码的值  
                if (code==200){//判断：如果响应码等于200时，获取返回过来的是XML数据  
                    //通过流的形式读取  
                    InputStream inputStream=httpURLConnection.getInputStream();  
                    //测试：是否拿到值  
                    String str=null;  
                    //字符流  
//                    BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(inputStream));//把字符流转成字节流  
//                    while ((str=bufferedReader.readLine())!=null){  
//                        Log.i("test", "doInBackground: ");}  

                    // 解析XML：  1、DOM  2、SAX  3、PULL  

                  //  三、使用pull解析  
                    try {  
                        //01、pull解析:需要jar包，写一个类即可（XMLpullparser）--XMLpull解析器  
                        XmlPullParser pullParser= Xml.newPullParser();  
                        pullParser.setInput(inputStream,"utf-8");//获得数流形式以及编码格式  
                        //02、通过解析器拿到事件类型：开始标签，结束标签，开始文档，结束文档，文本  
                        int type=pullParser.getEventType();//type-- 开始文档  
                        //03、拿到开始文档进行判断  
                        while (type!=XmlPullParser.END_DOCUMENT){//如果开始文档不等于结束标签,type必须赋值，否则会出现死循环  
                            //type不断的改变，需要通过switch来判断  
                            switch (type){  
                                case XmlPullParser.START_TAG://如果是开始标签  
                                    //获取开始标签的名字  
                                   String startname= pullParser.getName();  
                                    if ("fq".equals(startname)){  
                                        //实列化对象  
                                        userEntity1 = new UserEntity();  
                                        String name=pullParser.getAttributeValue(0);//通过解析器得到值  
                                        userEntity1.setUname(name);  
                                    }else if ("content".equals(startname)){  
                                       String content= pullParser.nextText();//通过解析器拿到下一个文本内容  
                                        userEntity1.setContent(content);  
                                    }else if ("anthour".equals(startname)){  
                                        String anthour= pullParser.nextText();//通过解析器拿到下一个文本内容  
                                        userEntity1.setAnthour(anthour);  
                                    }  
                                    break;  
                                case  XmlPullParser.END_TAG://如果是结束标签  
                                    //获取结束标签  
                                   String sname= pullParser.getName();//通过pull解析器获取结束标签的名字  
                                    if ("fq".equals(sname)){  
                                        list.add(userEntity1);  
                                    }  
                                    break;  
                            }  
                            type=pullParser.next();//通过解析器拿到下一个的值  
                        }  
                    } catch (XmlPullParserException e) {  
                        e.printStackTrace();  
                    }  


                }  
            } catch (MalformedURLException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            return list;  
        }  
        @Override//更新UI（数据）  
        protected void onPostExecute(Object o) {  
            super.onPostExecute(o);  
            List<UserEntity> list= (List<UserEntity>) o;  
            lists.addAll(list);  
            myadapter.notifyDataSetChanged();  
            pd.cancel();  
        }  
    }  
}

5、需要增加网络权限。

<uses-permission android:name="android.permission.INTERNET"></uses-permission>
习惯了沉默012
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android解析XML总结（SAX、Pull、Dom三种方式）附带DOM4J、JDOM
一朶婲
10-09 3843
摘要: 在android开发中，经常用到去解析xml文件，常见的解析xml的方式有一下三种：SAX、Pull、Dom解析方式。最近做了一个android版的CSDN阅读器，用到了其中的两种（sax,pull），今天对android解析xml的这三种方式进行一次 ... 在android开发中，经常用到去解析xml文件，常见的解析xml的方式有一下三种：SAX、Pull、Dom解析方式。最近做了一
Android解析XML的三种方式
热门推荐
d_shadow的博客
02-16 1万+
在Android中提供了三种解析XML的方式:SAX(Simple API XML),DOM(Document Objrect Model),以及Android推荐的Pull解析方式. 如图： 这里是获取网络XML： DOM，即对象文档模型，它是将整个XML文档载入内存(所以效率较低，不推荐使用)，每一个节点当做一个对象，结合代码分析 /** * DOM解析
Android中解析xml文件的几种方式
crazy_kid_hnf的博客
11-12 589
xml文件用于传输数据文件的。xml文件的格式如下： //在xml文件里面标签是可以自定义的 冰与火之歌 90 解析xml文件的方式有几种： 一：DOM方式解析xml文件 public class MainActivity extends Activity { private TextView textView1,textView2;
Android 解析XML（3种方法）
朝花偏不夕拾的博客
02-25 810
Android中的三种XML解析方式： DOM （Android不推荐 因为会一次加载所有的文件） SAX PULL （是边读边解析） 首先要在服务端生成XML 生成XML要在 Eclipse 里编写（用的是SSH框架） Jsp代码： "java" contentType="text/html; charset=utf-8" pageEncoding="ut
【安卓笔记】安卓下xml文件的解析
RowandJJ
02-08 2310
安卓下解析xml文件有多种方式： dom: 通用性强，它会将XML文件的所有内容读取到内存中，然后允许您使用DOM API遍历XML树、检索所需的数据；简单直观，但需要将文档读取到内存，并不太适合移动设备； sax: SAX是一个解析速度快并且占用内存少的xml解析 器；采用事件驱动，它并不需要解析整个文档；实现：继承DefaultHandler，覆写startElement、
详解Android之解析XML文件三种方式（DOM，PULL，SAX）
08-31
本文将详细探讨Android中解析XML的三种主要方法：DOM（Document Object Model），PULL（Pull Parser）和SAX（Simple API for XML）。 1. DOM解析： DOM解析器将整个XML文件加载到内存中，构建一个树形结构，允许...
Android解析XML的三种方式SAX、Pull、Dom
01-04
最近做了一个android版的CSDN阅读器，用到了其中的两种（sax,pull），本文对android解析xml的这三种方式进行一次总结。 今天解析的xml示例（channels.xml）如下： <?xml version=1.0 encoding=utf-8?> ...
Android XML数据的三种解析方式
01-20
在Android开发中，处理XML数据是常见的任务，通常有三种主要的解析方式：DOM解析、SAX解析和PULL解析。每种解析方式都有其特点和适用场景。 1. DOM解析（Document Object Model） DOM解析是将整个XML文档加载到...
Android中三种解析xml方式
tianguzhiji的博客
07-24 248
Android中的三种XML解析方式 在Android中提供了三种解析XML的方式:SAX(Simple API XML),DOM(Document Objrect Model),以及Android推荐的Pull解析方式.下面就对三种解析方式一一详细阐述。 假设要要解析person.xml文档       zhangsan     21         lisi  
Android几种解析XML方式的比较
android开发笔记
07-31 269
一、使用SAX解析XML SAX(Simple API for XML) 使用流式处理的方式，它并不记录所读内容的相关信息。它是一种以事件为驱动的XML API，解析速度快，占用内存少。使用回调函数来实现。 缺点是不能倒退。 二、使用DOM解析XML DOM(Document Object Model) 是一种用于XML文档的对象模型，可用于直接访问XML文档的各个部分。它是一次性全部将内容...
android解析xml的三种方式,android解析xml三种方式.doc
weixin_28862545的博客
05-27 123
解析Xml有三种方式可选,sax ,dom ,pull??,,各有各的优点,但在android上是不推荐使用DOM来解析的一般都用SAX和PULL 这两个性能相近, SAX的解析方式大家可以去看MARS的教程 讲的也比较好喔PULL的话我个人觉得处理事件比较简单,所以就给不懂的同学详细讲讲,嘿嘿....希望大家都能明白感谢 传智的张老师,黎老师, 感谢勇军哥首先给大家看看我的笔记那么我们就开始吧很...
Android中三种主要的XML解析方法
大前端程序猿
12-02 1379
一、Android开发中三种主要的XML解析方法 在平时的工作和学习中，我们经常需要在android项目中解析XML文件，android为我们提供了三种解析XML的方法，分别是Sax解析、Pull解析和Dom解析，下面简要介绍下这三种解析方法： SAX解析器： SAX(Simple API for XML)解析器是一种基于事件的解析器，它的核心是事件处理模式，主要是围绕着事件源以及事件处
Android XML文件读取解析三种方式
最新发布
lqw_qgf的博客
07-26 2842
XML文件读取解析
Android XML布局文件解析过程源码解析
一口仨馍
08-22 7600
`mLayoutInflater.inflate(layoutResID, mContentParent)`。这行代码的作用是将我们的activity_main.xml填充到mContentParent中去。详见：[setContentView源码解析]。那么，这行代码怎么就将xml文件转换成了View或者ViewGroup了呢？
【android-tips】android xml布局总结篇
weixin_40581617的博客
10-11 567
一.背景         可能很多人跟我一样，做了好久的android程序，却一直没有认真地坐下来好好学习下xml文件的布局。其实有的时候我们用view绘制或是利用ADT的图形界面功能就可以轻松搞定布局，但是最好还是静下来学习下xml的布局文件具体写法。这一节我们要绘制如下图所示的界面。 二基础知识        首先我们要了解android到底有那些布局，和每个布局类型
Android 源码解析(01) xml布局文件解析——LayoutInflater源码解析
Jejay的专栏
07-16 1467
备注：本文所用到的源码部分是Android 5.1.1，部分是Android4.2.2的 总述 Android界面上的每一个控件都是一个个View，但是Android也提供了通过xml文件来进行布局控制，那么xml布局文件如何转成最终的View的呢？转换利器就是LayoutInflater。 LayoutInflater的获取 1、通过Activity实例的getLayoutInfla
XML Layouts
duyankun的专栏
03-01 905
原文地址：http://developer.android.com/guide/topics/ui/declaring-layout.html 你的XML布局作为用户界面直接作用显示在Activity(活动、界面)上。它定义了布局结构，并把所有在布局里的元素显示给用户，你可以在两个方面声明你的布局：XML布局 - XML Layouts 直接在XML文件里声明你的UI元素：Androi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值