android读取xml

A. android中怎么读取xml节点文本然后一条一条地显示在TextView中

1. 首先这是两个问题

2. 读取xml节点是一个问题，显示在textview中又是一个问题

3. 先以以已经读出来了一条xml文件的节点为例

4. textview的显示详细说明一下

5. 首先在textview上下加入ScrollView以便有滚动条显示
   

6. 

7. 设置好之后节点内的信息就会分行的显示出来了。并且有换行的，每个节点显示一行
   

B. android怎么从xml文件里面提取数据

一、环境：
主机:WIN8
开发环境:Eclipse
二、说明:
1.打开sd卡中的xml文件，如果不存在，这新建一个，并写入默认配置
2.读取xml文件
三、xml文件格式:

<?xml version="1.0" encoding="UTF-8" standalone="true"?>
-<config>
<title>远程视频会见系统</title>
<local_port>12600</local_port>
<schele_service_ip>10.58.1.59</schele_service_ip>
<schele_service_port>12601</schele_service_port>
</config>

四、源代码:

package com.example.helloanychat;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import android.os.Environment;
import android.util.Log;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xmlpull.v1.XmlPullParserFactory;
import org.xmlpull.v1.XmlSerializer;
/**
* 配置信息类
* 新建日期:2014/12/8 by jdh
*/
public class Config implements IF_Config {
//配置信息
private Config_Info config_info = new Config_Info();
/**
* 构造函数
*/
public Config() {
boolean ok;
File sd_path;
File file_cfg_dir;
File file_cfg;
FileOutputStream out;
String str;
FileInputStream in;
//得到本机ip地址
config_info.local_ip = getLocalIpAddress();
System.out.printf("本机ip:%s\n", config_info.local_ip);
//获取SD卡目录
sd_path = Environment.getExternalStorageDirectory();
//判断文件夹是否存在
file_cfg_dir = new File(sd_path.getPath() + "//Remote_Meeting");
if (!file_cfg_dir.exists() && !file_cfg_dir.isDirectory()) {
System.out.println("配置文件夹Remote_Meeting不存在!");
ok = file_cfg_dir.mkdirs();
if (ok) {
System.out.println("创建文件夹成功!");
} else {
System.out.println("创建文件夹失败!");
}
}
//判断配置文件是否存在
file_cfg = new File(file_cfg_dir.getPath(),"cfg.xml");
if (!file_cfg.exists())
{
System.out.println("配置文件cfg.xml不存在!");
try {
file_cfg.createNewFile();
System.out.println("创建文件cfg.xml成功!");
//生成初始化的配置数据
try {
out = new FileOutputStream(file_cfg);
//保存默认配置
config_info.title = "远程视频会见系统";
config_info.local_port = 12600;
config_info.schele_server_ip = "10.58.1.59";
config_info.schele_server_port = 12601;
str = proce_xml_string(config_info);
out.write(str.getBytes());
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
config_info.title = "远程";
config_info.local_port = 126;
config_info.schele_server_ip = "10.5";
config_info.schele_server_port = 12;
System.out.printf("----222222222%s,%d,%s,%d\n",config_info.title,config_info.local_port,
config_info.schele_server_ip,config_info.schele_server_port);
//解析xml文件
try {
in = new FileInputStream(file_cfg);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(in);
// 获取根节点
Element root = document.getDocumentElement();
NodeList node = root.getChildNodes();
//获得第1子节点:标题
config_info.title = node.item(0).getFirstChild().getNodeValue();
//获得第2子节点:本机端口
config_info.local_port = Integer.parseInt(node.item(1).getFirstChild().getNodeValue());
//获得第3子节点:调度服务器ip
config_info.schele_server_ip = node.item(2).getFirstChild().getNodeValue();
//获得第4子节点:调度服务器端口
config_info.schele_server_port = Integer.parseInt(node.item(3).getFirstChild().getNodeValue());
System.out.printf("----222222222%s,%d,%s,%d\n",config_info.title,config_info.local_port,
config_info.schele_server_ip,config_info.schele_server_port);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Config_Info get_config_info() {
return config_info;
}
/**
* 得到本机ip地址
* @return 本机ip地址
*/
private String getLocalIpAddress() {
try {
for (Enumeration<NetworkInterface> en = NetworkInterface
.getNetworkInterfaces(); en.hasMoreElements();) {
NetworkInterface intf = en.nextElement();
for (Enumeration<InetAddress> enumIpAddr = intf
.getInetAddresses(); enumIpAddr.hasMoreElements();) {
InetAddress inetAddress = enumIpAddr.nextElement();
//if (!inetAddress.isLoopbackAddress()) {
if (!inetAddress.isLoopbackAddress() && !(inetAddress instanceof Inet6Address)) {
return inetAddress.getHostAddress().toString();
}
}
}
} catch (SocketException ex) {
Log.e("WifiPreference IpAddress", ex.toString());
}
return null;
}
/**
* 生成xml配置文件的String数据流
* Config_Info的本机ip信息不会保存
* @param info:配置信息
* @return xml的String数据流
*/
private String proce_xml_string(Config_Info info) {
StringWriter stringWriter = new StringWriter();
try {
// 获取XmlSerializer对象
XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
XmlSerializer xmlSerializer = factory.newSerializer();
// 设置输出流对象
xmlSerializer.setOutput(stringWriter);
//开始标签
xmlSerializer.startDocument("utf-8", true);
xmlSerializer.startTag(null, "config");
//标题
xmlSerializer.startTag(null, "title");
xmlSerializer.text(info.title);
xmlSerializer.endTag(null, "title");
//本机端口
xmlSerializer.startTag(null, "local_port");
xmlSerializer.text(Integer.toString(info.local_port));
xmlSerializer.endTag(null, "local_port");
//调度服务器ip
xmlSerializer.startTag(null, "schele_service_ip");
xmlSerializer.text(info.schele_server_ip);
xmlSerializer.endTag(null, "schele_service_ip");
//调度服务器端口
xmlSerializer.startTag(null, "schele_service_port");
xmlSerializer.text(Integer.toString(info.schele_server_port));
xmlSerializer.endTag(null, "schele_service_port");
xmlSerializer.endTag(null, "config");
xmlSerializer.endDocument();
} catch (Exception e) {
e.printStackTrace();
}
return stringWriter.toString();
}
}

C. android里面怎么解析xml

Android解析xml文件总共有三种方法，分别是：

1. SAX解析XML文件：SAX是一个解析速度快并且占用内存少的xml解析器，非常适合用于Android等移动设备。SAX解析XML文件采用的是事件驱动，也就是说，它并不需要解析完整个文档，在按内容顺序解析文档的过程中，SAX会判断当前读到的字符是否合法XML语法中的某部分，如果符合就会触发事件。所谓事件，其实就是一些回调（callback）方法，这些方法(事件)定义在ContentHandler接口。如下代码：

   
   

   publicstaticList<Person>readXML(InputStreaminStream){
   try{
   //创建解析器
   SAXParserFactoryspf=SAXParserFactory.newInstance();
   SAXParsersaxParser=spf.newSAXParser();
   
   //设置解析器的相关特性，true表示开启命名空间特性
   saxParser.setProperty("http://xml.org/sax/features/namespaces",true);
   XMLContentHandlerhandler=newXMLContentHandler();
   saxParser.parse(inStream,handler);
   inStream.close();
   
   returnhandler.getPersons();
   }catch(Exceptione){
   e.printStackTrace();
   }
   
   returnnull;
   }
   
   
   //SAX类：DefaultHandler，它实现了ContentHandler接口。在实现的时候，只需要继承该类，重载相应的方法即可。
   {
   
   privateList<Person>persons=null;
   privatePersoncurrentPerson;
   privateStringtagName=null;//当前解析的元素标签
   
   publicList<Person>getPersons(){
   returnpersons;
   }
   
   //接收文档开始的通知。当遇到文档的开头的时候，调用这个方法，可以在其中做一些预处理的工作。
   @Override
   publicvoidstartDocument()throwsSAXException{
   persons=newArrayList<Person>();
   }
   
   //接收元素开始的通知。当读到一个开始标签的时候，会触发这个方法。其中namespaceURI表示元素的命名空间；
   //localName表示元素的本地名称（不带前缀）；qName表示元素的限定名（带前缀）；atts表示元素的属性集合
   @Override
   publicvoidstartElement(StringnamespaceURI,StringlocalName,StringqName,Attributesatts)throwsSAXException{
   
   if(localName.equals("person")){
   currentPerson=newPerson();
   currentPerson.setId(Integer.parseInt(atts.getValue("id")));
   }
   
   this.tagName=localName;
   }
   
   //接收字符数据的通知。该方法用来处理在XML文件中读到的内容，第一个参数用于存放文件的内容，
   //后面两个参数是读到的字符串在这个数组中的起始位置和长度，使用newString(ch,start,length)就可以获取内容。
   @Override
   publicvoidcharacters(char[]ch,intstart,intlength)throwsSAXException{
   
   if(tagName!=null){
   Stringdata=newString(ch,start,length);
   if(tagName.equals("name")){
   this.currentPerson.setName(data);
   }elseif(tagName.equals("age")){
   this.currentPerson.setAge(Short.parseShort(data));
   }
   }
   }
   
   //接收文档的结尾的通知。在遇到结束标签的时候，调用这个方法。其中，uri表示元素的命名空间；
   //localName表示元素的本地名称（不带前缀）；name表示元素的限定名（带前缀）
   @Override
   publicvoidendElement(Stringuri,StringlocalName,Stringname)throwsSAXException{
   
   if(localName.equals("person")){
   persons.add(currentPerson);
   currentPerson=null;
   }
   
   this.tagName=null;
   }
   }

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

3. Pull解析器解析XML文件： Pull解析器的运行方式与 SAX 解析器相似。它提供了类似的事件，如：开始元素和结束元素事件，使用parser.next()可以进入下一个元素并触发相应事件。事件将作为数值代码被发送，因此可以使用一个switch对感兴趣的事件进行处理。当元素开始解析时，调用parser.nextText()方法可以获取下一个Text类型元素的值
   

D. 如何获取android 下的StreamingAssets文件夹中的xml文件

assets文件夹里面的文件都是保持原始的文件格式，需要用AssetManager以字节流的形式读取文件。
assets的读取方式:
1. 先在Activity里面调用getAssets() 来获取AssetManager引用。
2. 再用AssetManager的open(String fileName, int accessMode) 方法则指定读取的文件以及访问模式就能得到输入流InputStream。
3. 然后就是用已经open file 的inputStream读取文件，读取完成后记得inputStream.close() 。
4.调用AssetManager.close() 关闭AssetManager。
需要注意的是，来自Resources和Assets 中的文件只可以读取而不能进行写的操作

E. android 读取多层XML

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.xmlpull.v1.XmlPullParser;
import android.content.Context;
import android.util.Log;
import android.util.Xml;
class Formation {
int id;//为了简单，不写get，set方法
Type type;
}
class Type {
int id;
String name;
}
public class XMLPaser {
static final String TAG = "XMLPaser";
private static final String ns = null;
private Context context;
public XMLPaser(Context context) {
this.context = context;
}
public List<Formation> parse(String xmlPath) {
List<Formation> forList = new ArrayList<Formation>();
Formation formation = null;
InputStream stream = null;
XmlPullParser xmlParse = Xml.newPullParser();
try {
stream = this.context.getResources().getAssets().open(xmlPath);//xml文件放在Assert目录
xmlParse.setInput(stream, "utf-8");
int evnType = xmlParse.getEventType();//事件驱动
while (evnType != XmlPullParser.END_DOCUMENT) {//文档结束
switch (evnType) {
case XmlPullParser.START_TAG:/启动标签
String tag = xmlParse.getName();
if (tag.equalsIgnoreCase("formation")) {//找到formation
formation = new Formation();
formation.id = Integer.parseInt(xmlParse
.getAttributeValue(ns, "id"));//得到id属性
} else if (formation != null) {//进入formation里面
if (tag.equalsIgnoreCase("type")) {//找到type
formation.type = new Type();
formation.type.id = Integer.parseInt(xmlParse
.getAttributeValue(ns, "id"));
}
if (formation.type != null) {//进到type里面
if (tag.equalsIgnoreCase("name")) {//得到name值
formation.type.name = xmlParse.nextText();
}
}
}
break;
case XmlPullParser.END_TAG:
if (xmlParse.getName().equalsIgnoreCase("formation")
&& formation != null) {
forList.add(formation);
formation = null;
}
break;
default://第一次
break;
}
evnType = xmlParse.next();
}
} catch (Exception e) {
Log.d(TAG, e.toString());
}
return forList;
}
}

F. android 怎么读取一个xml

关于具体使用方法，举例如下：
1、updatelog.xml文件位于res/xml/文件夹下：
<?xml version="1.0" encoding="utf-8"?>
<updatelog>
<release
version="1.0"
versioncode="1.1">
<log>1、这个文件在res/xml文件夹下；</log>
<log>2、这个文件的名字是“updatelog.xml”</log>
<log>3、这是一个xml文件</log>
</release>
</updatelog>

2、在代码中调用方法如下：
public class ResourcesActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView( R.layout.resources_layout );
mTextView = ( TextView )findViewById( R.id.textId );
getFileResources( );
}

private void getFileResources( ){
String packageName = getPackageName( );
try {
Resources resources = this.getPackageManager( ).getResourcesForApplication( packageName );
int resId = resources.getIdentifier( "updatelog", "xml", packageName );
String log = getUpdatelog( resId, resources );

int appId = resources.getIdentifier( "action_settings", "string", packageName );
String appName = resources.getString( appId );

mTextView.setText( appName + "\n" + log );
} catch (NameNotFoundException e) {
e.printStackTrace();
}
}

private String parseTag( XmlResourceParser xml ) throws XmlPullParserException, IOException {
String result = "Version: "+ xml.getAttributeValue(null, "version") + "\n" + "VersionCode: " + xml.getAttributeValue(null, "versioncode") + "\n";
int eventType = xml.getEventType( );
while( ( eventType != XmlPullParser.END_TAG ) || ( xml.getName( ).equals( "log" ) ) ) {
if( (eventType == XmlPullParser.START_TAG) && ( xml.getName( ).equals( "log" ) ) ) {
eventType = xml.next( );
result = result + xml.getText( ) + "\n";
}
eventType = xml.next( );
}

return result;
}

private String getUpdatelog( int resourceId, Resources resource ) {
String result = "";
XmlResourceParser xmlResParser = resource.getXml( resourceId );
try {
int eventType = xmlResParser.getEventType( );
while ( eventType != XmlPullParser.END_DOCUMENT ) {
if ( ( eventType == XmlPullParser.START_TAG ) && ( xmlResParser.getName( ).equals( "release" ) ) ) {
result = result + parseTag( xmlResParser );

}
eventType = xmlResParser.next( );
}
} catch (XmlPullParserException e) {
System.out.println( e.getMessage( ) );
} catch (IOException e) {
System.out.println( e.getMessage( ) );
} finally {
xmlResParser.close( );
}

return result;
}

private TextView mTextView = null;
}

G. 如何获取android 下的StreamingAssets文件夹中的xml文件

assets文件夹里面的文件都是保持原始的文件格式，需要用AssetManager以字节流的形式读取文件。
assets的读取方式:
1. 先在Activity里面调用getAssets() 来获取AssetManager引用。
2. 再用AssetManager的open(String fileName, int accessMode) 方法则指定读取的文件以及访问模式就能得到输入流InputStream。
3. 然后就是用已经open file 的inputStream读取文件，读取完成后记得inputStream.close() 。
4.调用AssetManager.close() 关闭AssetManager。
需要注意的是，来自Resources和Assets 中的文件只可以读取而不能进行写的操作

H. 如何获取android 下的StreamingAssets文件夹中的xml文件

assets文件夹里面的文件都是保持原始的文件格式，需要用AssetManager以字节流的形式读取文件。
assets的读取方式:
1. 先在Activity里面调用getAssets() 来获取AssetManager引用。
2. 再用AssetManager的open(String fileName, int accessMode) 方法则指定读取的文件以及访问模式就能得到输入流InputStream。
3. 然后就是用已经open file 的inputStream读取文件，读取完成后记得inputStream.close() 。
4.调用AssetManager.close() 关闭AssetManager。
需要注意的是，来自Resources和Assets 中的文件只可以读取而不能进行写的操作。

I. android 怎么读取res下的xml

相当于读取res下面的文件，读取成string类型，然后在通过xml解析器解析就行。下面是读取res下面文件的例子，请看截图，例子来自android学习手册，android学习手册，里面有源码。android学习手册包含9个章节，108个例子，源码文档随便看，例子都是可交互，可运行，源码采用android studio目录结构，高亮显示代码，文档都采用文档结构图显示，可以快速定位。360手机助手中下载,图标上有贝壳

方法一、将要读取的txt文件拷贝到Android工程目录下的assets文件夹下

方法二、在res文件夹下新建raw文件夹，将txt拷贝到该目录下

本方法是从assets中读取

/**
* 从assets中读取txt
*/
private void readFromAssets() {
try {
InputStream is = getAssets().open("qq.txt");
String text = readTextFromSDcard(is);
textView.setText(text);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

本方法是从raw中读取

/**
* 从raw中读取txt
*/
private void readFromRaw() {
try {
InputStream is = getResources().openRawResource(R.raw.qq);
String text = readTextFromSDcard(is);
textView.setText(text);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

本方法是解析输入流，返回txt中的字符串

/**
* 按行读取txt
*
* @param is
* @return
* @throws Exception
*/
private String readTextFromSDcard(InputStream is) throws Exception {
InputStreamReader reader = new InputStreamReader(is);
BufferedReader bufferedReader = new BufferedReader(reader);
StringBuffer buffer = new StringBuffer("");
String str;
while ((str = bufferedReader.readLine()) != null) {
buffer.append(str);
buffer.append(" ");
}
return buffer.toString();
}