import org.kxml.*;
import org.kxml.parser.*; 

try {
Reader r = .....;
XmlParser parser = new XmlParser( r );
}
catch( java.io.IOException e ){
// handle exception....
} 

// ?取字串 (exception handling omitted)
String xml = "some xml";
ByteArrayInputStream bin = 
new ByteArrayInputStream( xml.getBytes() );
XmlParser parser = new XmlParser( new InputStreamReader( bin ) ); 

// Read from web (exception handling omitted)
HttpConnection conn = .....;
InputStreamReader doc = 
new InputStreamReader( conn.openInputStream() );
XmlParser parser = new XmlParser( doc );

try {
boolean keepParsing = true; 
while( keepParsing ){
ParseEvent event = parser.read(); 
switch( event.getType() ){
case Xml.START_TAG:
..... // handle start of an XML tag
break;
case Xml.END_TAG:
..... // handle end of an XML tag
break;
case Xml.TEXT:
..... // handle text within a tag
break;
case Xml.WHITESPACE:
..... // handle whitespace
break;
case Xml.COMMENT:
..... // handle comment
break;
case Xml.PROCESSING_INSTRUCTION:
..... // handle XML PI
break;
case Xml.DOCTYPE:
..... // handle XML doctype
break;
case Xml.END_DOCUMENT:
..... // end of document;
keepParsing = false;
break;
}
}
}
catch( java.io.IOException e ){ 
}

package com.ericgiguere.techtips;

import java.io.*;
import java.util.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
import nanoxml.*;
import org.kxml.*;
import org.kxml.parser.*;

/**
* Simple MIDlet that demonstrates how an XML document can be
* parsed using kXML or NanoXML.
*/

public class XMLTest extends MIDlet {

// Our XML document -- normally this would be something you
// download.

private static String xmlDocument =
"apple" +
"orange" +
"pear";

private Display display;
private Command exitCommand = new Command( "Exit",
Command.EXIT, 1 );

public XMLTest(){
}

protected void destroyApp( boolean unconditional )
throws MIDletStateChangeException {
exitMIDlet();
}

protected void pauseApp(){
}

protected void startApp() throws MIDletStateChangeException {
if( display == null ){ // first time called...
initMIDlet();
}
}

private void initMIDlet(){
display = Display.getDisplay( this );

String [] items;

//items = parseUsingNanoXML( xmlDocument );
items = parseUsingkXML( xmlDocument );

display.setCurrent( new ItemList( items ) );
}

public void exitMIDlet(){
notifyDestroyed();
}

// Parses a document using NanoXML, looking for
// "item" nodes and returning their content as an
// array of strings.

private String[] parseUsingNanoXML( String xml ){
kXMLElement root = new kXMLElement();

try {
root.parseString( xml );

Vector list = root.getChildren();
Vector items = new Vector();

for( int i = 0; i < list.size(); ++i ){
kXMLElement node = 
(kXMLElement) list.elementAt( i );
String tag = node.getTagName();

if( tag == null ) continue;
if( !tag.equals( "item" ) ) continue;

items.addElement( node.getContents() );
}

String[] tmp = new String[ items.size() ];
items.copyInto( tmp );
return tmp;
}
catch( kXMLParseException ke ){
return new String[]{ ke.toString() };
}
}

// Parses a document using kXML, looking for "item"
// nodes and returning their content as an
// array of strings.

private String[] parseUsingkXML( String xml ){
try {
ByteArrayInputStream bin =
new ByteArrayInputStream( 
xml.getBytes() );
InputStreamReader in = new InputStreamReader( bin );
XmlParser parser = new XmlParser( in );
Vector items = new Vector();

parsekXMLItems( parser, items );

String[] tmp = new String[ items.size() ];
items.copyInto( tmp );

return tmp;
}
catch( IOException e ){
return new String[]{ e.toString() };
}
}

private void parsekXMLItems( XmlParser parser, Vector items )
throws IOException {
boolean inItem = false;

while( true ){
ParseEvent event = parser.read();
switch( event.getType() ){
case Xml.START_TAG:
if( event.getName().equals( "item" ) ){
inItem = true;
}
break;
case Xml.END_TAG:
if( event.getName().equals( "item" ) ){
inItem = false;
}
break;
case Xml.TEXT:
if( inItem ){
items.addElement( event.getText() );

}
break;
case Xml.END_DOCUMENT:
return;
}
}
}

// Simple List UI component for displaying the list of
// items parsed from the XML document.

class ItemList extends List implements CommandListener {

ItemList( String[] list ){
super( "Items", IMPLICIT, list, null );
addCommand( exitCommand );
setCommandListener( this );
}

public void commandAction( Command c, Displayable d ){
if( c == exitCommand ){
exitMIDlet();
} 
}
}
}