6.线程生命周期和线程池
> 线程池:
> //像我们正常的一个应用线程一般在5,6个就是很多了,游戏应用线程比较多
> 1.预先创建
> 2.在任务没来之前,创建一定空闲线程
> 3.线程复用,减少频繁创建和销毁对象(创建线程的消耗很大的)
> JDK1.5版本以上提供了现成的线程池(我们就不用自己创建啦)
package com.test.testjva.thread;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//用的频率比较高的的2和3
public class ExcutorDemo {
public static void main(String[] args) {
//1.创建一个单线程的执行器
ExecutorService service = Executors.newSingleThreadExecutor();
//service.execute(new DownLoadThread());//线程还保留在这里,等待执行其他任务
//2.创建固定数量的线程执行器
ExecutorService servicefix = Executors.newFixedThreadPool(3);
/*servicefix.execute(new DownLoadThread());
servicefix.execute(new DownLoadThread());
servicefix.execute(new DownLoadThread());
servicefix.execute(new DownLoadThread());*/
//3.创建一个可缓存线程执行器,60s空闲将被回收(从内存中释放)
ExecutorService servicecache = Executors.newCachedThreadPool();
servicecache.execute(new DownLoadThread());
servicecache.execute(new DownLoadThread());
servicecache.execute(new DownLoadThread());
servicecache.execute(new DownLoadThread());
//4.无限的
ExecutorService servicesche = Executors.newScheduledThreadPool(3);
}
static class DownLoadThread implements Runnable{
public void run() {
for (int i = 0; i <= 100; i+=10) {
System.out.println(Thread.currentThread().getName()+"已下载"+i+"%");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
7.网络编程基本概念
> 连接一台电脑:
> 需要知道:1.ip2.端口号
>
> 程序开发结构:
> 1.c/s(客户端/服务器) qq
>
> C/S传输方式:
> 1.TCP:传输控制协议。3次握手(安全(例如:打电话))可靠的协议,面向连接的协议(java提供了java.net包)
>
> 2.UDP:数据报协议。直接发,不管你收不收得到(例如:看电视,你看不看我都播节目)
>
> 2.b/s(浏览器/服务器) 网站web,不安全
8.Socket概念
![这里写图片描述](https://img-blog.csdn.net/20160202114633497)
> 快递员:socket
>
> 数据发送过程:
> 1.产生socket
> 2.调用bind将socket的信息通知给驱动程序
> 3.应用程序把数据传给socket
> 4.驱动程序从socket中取出数据并通知网卡发送出去
> 接受数据过程:
> 1.产生socket
> 2.调用bind将socket的信息通知给驱动程序
> 3.驱动程序根据从网卡传送过来的数据报中”指定的目标端口号“,将处理的数据传送到相应的socket中,应用程序从socket中取数据
9.简单TCP程序传输程序
package com.test.testjva.serverAndClient;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class EchoServer {
public static void main(String[] args) {
//端口号从1024~65535
try {
ServerSocket ss = new ServerSocket(8001);
System.out.println("服务器已启动,正在等待连接...");
Socket socket = ss.accept();//等待客户端连接,该方法会阻塞(客户端执行了它才会执行)
InputStream in = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String data = br.readLine();
System.out.println("data"+data);
//返回响应
OutputStream out = socket.getOutputStream();
PrintStream ps = new PrintStream(out);
ps.println("data=="+data);
out.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
package com.test.testjva.serverAndClient;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
public class EchoClient {
//传输过程:
//1.客户端通过输出流把数据发送到服务器(客户端可以先写一个输入流等待着)
//2.服务器通过输入流得到数据后再通过输出流返回到客户端
//3.客户端用刚刚写好的输入流得到服务器传来的数据,然后读出来
//连接服务器
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost",8001);
System.out.println("连接成功!");
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
PrintStream ps = new PrintStream(out);
ps.println("hello");
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String data = br.readLine();
System.out.println("dataclient="+data);
out.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
10.服务器与多个客户端通信
package com.test.testjva.serverAndClient.muit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.test.testjva.thread.ExcutorDemo;
//多客户端通信的时候,使用多线程处理客户端发送来的请求
public class EchoMuitServer {
public static void main(String[] args) {
ExecutorService es = Executors.newCachedThreadPool();
//端口号从1024~65535
try {
ServerSocket ss = new ServerSocket(8001);
System.out.println("服务器已启动,正在等待连接...");
while(true){
Socket socket = ss.accept();//等待客户端连接,该方法会阻塞(客户端执行了它才会执行)
//每一次过来都传到线程中去,然后继续等待
es.execute(new ClientThread(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
//处理客户端请求的线程
static class ClientThread implements Runnable{
private Socket socket;
public ClientThread(Socket socket){
this.socket =socket;
}
public void run() {
try {
System.out.println("客户端的ip为:"+socket.getInetAddress().getHostName());
InputStream in = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
//返回响应
OutputStream out = socket.getOutputStream();
PrintStream ps = new PrintStream(out);
while(true) {
String data = br.readLine();
if(data == null || data.equals("bye")){
break;
}
System.out.println("data"+data);
ps.println("data=="+data);
}
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package com.test.testjva.serverAndClient.muit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;
public class MuitClient {
//传输过程:
//1.客户端通过输出流把数据发送到服务器(客户端可以先写一个输入流等待着)
//2.服务器通过输入流得到数据后再通过输出流返回到客户端
//3.客户端用刚刚写好的输入流得到服务器传来的数据,然后读出来
//连接服务器
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost",8001);
System.out.println("连接成功!");
boolean flag = true;
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
PrintStream ps = new PrintStream(out);
BufferedReader br = new BufferedReader(new InputStreamReader(in));
Scanner input = new Scanner(System.in);
while(flag){
System.out.println("请输入:");
String info = input.next();
if("bye".equals(info)){
flag = false;
}
ps.println(info);
info = br.readLine();
System.out.println("dataclient="+info);
}
out.close();
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
11.客户端与客户端通信
package com.test.testjva.serverAndClient;
public class Info {
private String to;
private String from;
private String info;
private int type;//0表示登录,1表示发送消息
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Info [to=" + to + ", from=" + from + ", info=" + info + "]";
}
public Info(String to, String from, String info) {
super();
this.to = to;
this.from = from;
this.info = info;
}
public Info() {
super();
// TODO Auto-generated constructor stub
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
}
package com.test.testjva.serverAndClient.client;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;
import com.test.testjva.serverAndClient.Info;
public class Client {
public static void main(String[] args) {
getClient();
}
private static void getClient() {
try {
Socket socket = new Socket("localhost",8001);
System.out.println("连接成功!");
boolean flag = true;
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
Scanner input = new Scanner(System.in);
System.out.println("请输入姓名:");
String name = input.nextLine();
Info info = new Info();
info.setFrom(name);
info.setType(0);
out.writeObject(info);
try {
info = (Info) in.readObject();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}//系统返回的信息
System.out.println(info.getInfo());
new Thread(new ReadInfoThread(in)).start();
while(flag){
info = new Info();
System.out.println("to:");
info.setTo(input.nextLine());
System.out.println("info:");
info.setInfo(input.nextLine());
info.setFrom(name);
info.setType(1);
out.writeObject(info);
}
out.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//接收消息的线程
static class ReadInfoThread implements Runnable{
private ObjectInputStream in;
public boolean flag = true;
public ReadInfoThread(ObjectInputStream in){
this.in = in;
flag = true;
}
public void run() {
while(flag) {
try {
Info info = (Info) in.readObject();
System.out.println("收到的消息;"+info.getInfo());
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package com.test.testjva.serverAndClient.client;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Vector;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.test.testjva.serverAndClient.Info;
public class Server {
public static void main(String[] args) {
ExecutorService es = Executors.newCachedThreadPool();
//用于存储客户端的服务线程
Vector<ClientThread> list = new Vector<ClientThread>();
//端口号从1024~65535
try {
ServerSocket ss = new ServerSocket(8001);
System.out.println("服务器已启动,正在等待连接...");
while(true){
Socket socket = ss.accept();//等待客户端连接,该方法会阻塞(客户端执行了它才会执行)
//每一次过来都传到线程中去,然后继续等待
ClientThread c = new ClientThread(socket,list);
es.execute(c);
}
} catch (IOException e) {
e.printStackTrace();
}
}
//处理客户端请求的线程
static class ClientThread implements Runnable{
private Socket socket;
private String name;
private Vector<ClientThread> list;
private ObjectOutputStream out;
private ObjectInputStream in;
public ClientThread(Socket socket, Vector<ClientThread> list){
list.add(this);
this.socket =socket;
this.list = list;
}
public void run() {
try {
System.out.println("客户端的ip为:"+socket.getInetAddress().getHostName());
out = new ObjectOutputStream(socket.getOutputStream());
in = new ObjectInputStream(socket.getInputStream());
while(true) {
Info info = null;
try {
info = (Info) in.readObject();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
if(info.getType() == 0) {
name = info.getFrom();
Info welcome = new Info();
welcome.setInfo("welcome"+name);
} else if(info.getType() == 1) {
for (int i = 0; i < list.size(); i++) {
ClientThread ct = list.get(i);
if(ct.name.equals(info.getTo())) {
ct.out.writeObject(info);
break;
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
12.反射-Class
package com.test.testjva.reflection;
public class Cat{
//public int count;
private String name;
private int age;
public Cat(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Cat() {
super();
// TODO Auto-generated constructor stub
}
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;
}
@Override
public String toString() {
return "Cat [name=" + name + ", age=" + age + "]";
}
private String privateTest(){
return "222";
}
}
package com.test.testjva.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Reflection1 {
public static void main(String[] args) {
getClassObj();
}
//获取一个class类对象
private static void getClassObj() {
Cat cat= new Cat("jack", 4);
//3中方式获得类信息
Class cls = cat.getClass();
Class cls2 = Cat.class;
try {
Class cls3 = Class.forName("com.test.testjva.reflection.Cat");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//通过类信息创建该对象,Cat的无参构造方法必须存在
try {
Cat catc = (Cat) cls2.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//获取构造方法
Constructor[] cons = cls2.getConstructors();
for (int i = 0; i < cons.length; i++) {
System.out.println(cons[i].getName());
}
try {
Constructor constss = cls2.getConstructor(String.class,int.class);
try {
Cat c = (Cat) constss.newInstance("jjjj",5);
System.out.println(c.getName());
} catch (Exception e) {
e.printStackTrace();
}
} catch (NoSuchMethodException | SecurityException e) {
e.printStackTrace();
}
//得到类信息
String name = cls2.getPackage().getName();
//获取所以可用(公共的public)方法
Method[] medhods = cls2.getMethods();
for (Method method : medhods) {
System.out.println(method.getName()+"\\");
}
//获取所以可用(公共的)属性
Field[] f= cls2.getFields();
for (Field field : f) {
System.out.println("--"+field.getName());
}
//获取本类中定义的所有方法包含private,不包含父类方法
Method[] mes = cls2.getDeclaredMethods();
for (Method method : mes) {
System.out.println(method.getName());
}
Field[] fd = cls2.getDeclaredFields();
for (Field field : fd) {
System.out.println("==="+field.getName());
System.out.println(Modifier.toString(field.getModifiers()));
System.out.println(field.getType().getName());
}
//通过反射可以调用类里面private的方法和属性
try {
Method md = cls2.getDeclaredMethod("privateTest");
md.setAccessible(true);
try {
String test = (String) md.invoke(cat);
System.out.println("test==="+test);
} catch (Exception e) {
e.printStackTrace();
}
} catch (NoSuchMethodException | SecurityException e1) {
e1.printStackTrace();
}
//在cat对象上获取属性值
try {
//运行时忽略访问修饰符的限制
fd[0].setAccessible(true);
String nameS = (String) fd[0].get(cat);
System.out.println(nameS);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
13.动态代理
package com.test.testjva.reflectiondaili;
public interface SubJect {
void shopping();
}
package com.test.testjva.reflectiondaili;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
//必须要做又不是核心业务的代码放在代理中去做
//自己写代理的情况比较少,写这个的目的是因为android里面有很多代理,便于理解别人的代码
//代理要做的事情
public class Proxy implements InvocationHandler{
private SubJect target;
public Proxy(SubJect target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("大量评估");
method.invoke(target, args);
//代购之后
System.out.println("满意度调查");
return null;
}
}
package com.test.testjva.reflectiondaili;
public class SuperMan implements SubJect{
@Override
public void shopping() {
System.out.println("哥有钱");
}
}
package com.test.testjva.reflectiondaili;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
SubJect s = new SuperMan();
com.test.testjva.reflectiondaili.Proxy proxy = new com.test.testjva.reflectiondaili.Proxy(s);
//动态创建一个代理对象(类加载器,)
SubJect obj = (SubJect) Proxy.newProxyInstance(s.getClass().getClassLoader(), s.getClass().getInterfaces(), proxy);
obj.shopping();
}
}
14.javabean反射和内省
package com.test.testjva.javabean;
public class User {
private String name;
private int num;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
@Override
public String toString() {
return "User [name=" + name + ", num=" + num + "]";
}
public User(String name, int num) {
super();
this.name = name;
this.num = num;
}
public User() {
super();
}
}
package com.test.testjva.javabean;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
//(反射和内省)前期用的比较少,写底层框架的时候,用的就比较多了,
//研究框架源代码的时候,就可以看懂了,很多框架源代码都是用反射和内省实现的
public class UserFractory {
private static Properties p = new Properties();
static {
InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/test/testjva/javabean/user.properties");
try {
p.load(in);
} catch (IOException e) {
e.printStackTrace();
}
}
public static User newUser(){
User u = null;
try {
String user = p.getProperty("user");
Class bClass = Class.forName(user);
u = (User) bClass.newInstance();
BeanInfo info = Introspector.getBeanInfo(User.class);
//获取属性描述器
PropertyDescriptor[] pds = info.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : pds) {
String name = propertyDescriptor.getName();
if(name.equals("name")) {
Method md = propertyDescriptor.getWriteMethod();
md.invoke(u, p.getProperty("name"));
}
else if(name.equals("num")) {
Method md = propertyDescriptor.getWriteMethod();
int num = Integer.parseInt(p.getProperty("num"));
md.invoke(u, num);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return u;
}
}
package com.test.testjva.javabean;
public class UserTest {
public static void main(String[] args) {
User user = UserFractory.newUser();
System.out.println("user="+user);
}
}
创建文件:user.properties
user = com.test.testjva.javabean.User
name = my
num = 9
15.泛型
package com.test.testjva.javabean.generic;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Vector;
public class GenericDemo {
/*
1.通配符
<? extends T> 表示类型的上界,传T的子类 <? super T> 表示类型下界,传T的父类 2.泛型接口 public interface IEat { public void eat(T t); } //你传入的是什么类型,返回的就是什么类型的方法 class IEatImpl implements IEat { @Override public void eat(String t) { System.out.println(t); } } 3.泛型方法 //T[]表示返回值类型,表示泛型化 public static T[] func(T[] array,int i,int t){ T temp = array[i]; array[i] = array[t]; array[t] = array[i]; return array; } 4.嵌套泛型的使用 Map}
package com.test.testjva.javabean.generic;
//T的上限就代表传入的?(问号)必须是Number的子类(比如Float,Integer),String就不可以;T super Number是相反的,
/*? 通配符类型
<? extends T> 表示类型的上界,传T的子类 <? super T> 表示类型下界,传T的父类 extends 可用于的返回类型限定,不能用于参数类型限定。 super 可用于参数类型限定,不能用于返回类型限定。 >带有super超类型限定的通配符可以向泛型对易用写入,带有extends子类型限定的通配符可以向泛型对象读取。——《Core */ public class Person { private String name; private T age; public String getName() { return name; } public void setName(String name) { this.name = name; } public T getAge() { return age; } public void setAge(T age) { this.age = age; } public Person(String name, T age) { super(); this.name = name; this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } } package com.test.testjva.javabean.generic; public interface IEat { public void eat(T t); } //你传入的是什么类型,返回的就是什么类型的方法 class IEatImpl implements IEat { @Override public void eat(String t) { System.out.println(t); } } ``` 16.正则表达式 > 正则表达式在android中用的比较少,因为正则表达式有一定的效率问题,效率比较低 ``` package com.test.testjva.javabean.Regular; import java.util.regex.Matcher; import java.util.regex.Pattern; public class Regular { //java.util.regex提供正则表达式的支持 //Matcher类,Pattern类 public static void main(String[] args) { String s = "1111"; if(s.matches("\\d+")){ } //参数名是regex的方法都是可以传正则表达式的 //直接使用俩个类的匹配的方式比较少,一般都是用上面的方法 //pattern使用方式 Pattern p = Pattern.compile("aaaa"); Matcher m = p.matcher("aaaa"); boolean b = m.matches(); System.out.println(b); } } ``` 17.DOM解析和SAX解析 ``` package com.test.demo22; import java.io.InputStream; import java.util.ArrayList; import java.util.List; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; /* Dom解析的特点:在服务器端开发用的比较多,因为服务器内存大,不在乎 1.整个文档载入内存(占内存),灵活性好,API简单,以树形结构存储 2.SAX(simple API xml),边读边解析,不占用内存,基于事件驱动,不灵活,顺序读取,不能来回跳,速度快(使用与在性能要求较高的设备上使用(比如android)) 在android中通常就用SAX解析 */ public class DomParse { public static void main(String[] args) { try { List domList = parseXMLByDom(); List saxList = parseXMLBySAX(); for (Person p : saxList) { System.out.println(p); } } catch (Exception e) { e.printStackTrace(); } } private static List parseXMLBySAX() throws Exception { //创建解析工厂 SAXParserFactory factory = SAXParserFactory.newInstance(); //生成解析器 SAXParser sax = factory.newSAXParser(); InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/test/demo22/person.xml"); PersonHandler ph = new PersonHandler(); sax.parse(in, ph); return ph.getPersons(); } private static List parseXMLByDom() throws Exception { // 创建一个文档解析工厂 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); InputStream in = Thread.currentThread().getContextClassLoader() .getResourceAsStream("com/test/demo22/person.xml"); // xml文件的输入流放入解析器中 Document doc = builder.parse(in); Person p = null; List pList = new ArrayList(); NodeList personList = doc.getElementsByTagName("Person"); System.out.println(personList.getLength()); for (int j = 0; j < personList.getLength(); j++) { Node personNode = personList.item(j); String personid = personNode.getAttributes().getNamedItem("personId").getNodeValue(); p = new Person(); p.setPersonId(personid); NodeList personChilds = personNode.getChildNodes(); for (int k = 0; k < personChilds.getLength(); k++) { Node childNode = personChilds.item(k); String name = childNode.getNodeName(); if (name.equals("name")) { p.setName(childNode.getFirstChild().getNodeValue()); } else if (name.equals("age")) { p.setAge(childNode.getFirstChild().getNodeValue()); } else if (name.equals("sex")) { p.setSex(childNode.getFirstChild().getNodeValue()); } } pList.add(p); } return pList; } } package com.test.demo22; public class Person { private String personId; private String name; private String sex; private String age; public String getPersonId() { return personId; } public void setPersonId(String personId) { this.personId = personId; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } @Override public String toString() { return "Person [personId=" + personId + ", name=" + name + ", sex=" + sex + ", age=" + age + "]"; } public Person(String personId, String name, String sex, String age) { super(); this.personId = personId; this.name = name; this.sex = sex; this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } } package com.test.demo22; import java.util.ArrayList; import java.util.List; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; /* 数据处理器 */ public class PersonHandler extends DefaultHandler { private List persons; private Person p; private String tag;// 记录标签名 public List getPersons() { return persons; } // 开始文档解析 @Override public void startDocument() throws SAXException { super.startDocument(); persons = new ArrayList(); System.out.println("开始解析文档"); } @Override public void endDocument() throws SAXException { super.endDocument(); System.out.println("结束解析文档"); } // 开始解析标签<> // 如果标签是的情况的时候,localName只拿person,qName就是拿到(所有标签)a:person @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { super.startElement(uri, localName, qName, attributes); if (qName.equals("Person")) { p = new Person(); String personId = attributes.getValue("personId"); p.setPersonId(personId); } tag = qName; } @Override public void endElement(String uri, String localName, String qName) throws SAXException { super.endElement(uri, localName, qName); if("Person".equals(qName)) { persons.add(p); } tag = null; } // 解析字符 // 处理文本内容(包括空格) @Override public void characters(char[] ch, int start, int length) throws SAXException { super.characters(ch, start, length); String content = new String(ch, start, length); if (tag != null) { if (tag.equals("name")) { p.setName(new String(ch, start, length)); } else if (tag.equals("sex")) { p.setAge(new String(ch, start, length)); } else if (tag.equals("age")) { p.setSex(new String(ch, start, length)); } } } } 创建文件:person.xml <?xml version="1.0" encoding="UTF-8"?><Person personId="11">
<name>张飞</name>
<sex>男</sex>
<age>30</age>
</Person>
<Person personId="22">
<name>关于</name>
<sex>女</sex>
<age>22</age>
</Person>
18.Jdom解析和Dom4j解析
package com.test.demo22;
//API简化了,速度比Dom解析快
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;