数据解析

XML数据解析

Pull 解析:

XmlPullParserFactory factory=XmlPullParserFactory.newInstance();
XmlPullParser parser=factory.newPullParser();
FileInputStream fis=new FileInputStream("user.xml","utf-8");
parser.setInput(fis,"utf-8");
int event=parser.getEventType();
while(event!=XmlPullParser.END_DOCUMENT){//判断是否到达文件末尾
    switch(event){
        case XmlPullParser.START_DOCUMENT://判断是否是文件开始标签
            list=new ArrayList<Person>();
            break;
        case XmlPullParser.START_TAG:
            String tagName=parser.getName(); //获取子标签名字
            if("person".equals(tagName)){
                person=new Person();
                int count=parser.getAttributeCount();//获取子标签名下的属性个数
                for(int i=0;i<count;i++){
                    //获取属性名字
                    String attrName=parser.getAttributeName(i);
                    //获取属性值
                    String attrValue=parser.getAttributeValue(i);
                }
            }
            else if("name".equals(tagName)){
                worker.setName(parser.nextText());
            }
            break;
        case XmlPullParser.END_TAG:
            if("person".equals(parser.getName())){
                list.add(person);
                person=null;
            }
            break;
    }
    event=parser.next();
}

SAX解析：

SAXParserFactory factory=SAXParserFactory.newInstance();
SAXParser parser=factory.newSAXParser();
File file=new File("user.xml","utf-8");
MyHandler handler=new MyHandler();

class MyHandler extends DefaultHandler{
    public void startDocument(){//文件开始
        list=new ArrayList<Person>();
    }
    public void startElement(String uri,String localName,String qName,Atrributes attributes){
        tagName=qName;
        if("person".equals(tagName)){
            person=new Person();
            if(attributes!=null){//属性
                for(int i=0;i<attributes.getLength();i++){
//得到属性名
String attrName=attributes.getValue(i);                 
                }               
            }
        }
    }
    public void characters(char[] ch,int start,int length){
        String data=new String(ce,start,length);
    }
    public void endElement(String url,String localName,String qName){//结束标签
        tagName="";
        if("person".equals(qName)){
            list.add(person);
        }
    }
    public void endDocument(){}  //文档结束标签
}
//解析数据
parser.parse(file,hander);

GSON: 序列化的Bean

生成Json字符串：
    Gson gson=new Gson();
    String jsonStr=Gson.toJson(obj);
        obj可以是：
            单个对象
                Person
            对象的集合
                list<Person>
            字符串的集合
                list<String>
            Map集合的集合
                list<Map<String,Object>>
解析Json字符串：
    结果是单个对象
        Person person=new Person();
        Gson gson=new Gson();
        person=gson.fromJson(jsonStr,Person.class);
    结果是list集合：
        List<T> list=null;
        Gson gson=new Gson();
        list=gson.fromJson(jsonStr,new TypeToken<List<T>>(){}.getType());  //T可以是String Person
        结果是Map的集合：
            List<Map<String,Object>> listMap=null;
            Gson gson=new Gson();
            listMap=gson.fromJson(jsonStr,new TypeToken<List<Map<String,Object>>>(){}.getType());

FastJson:

装换成Json形式的数据：
    JSON.toJSONString(obj); //obj可以是单个对象，对象的集合，字符串的集合，Map对象的集合
对Json形式的数据进行解析：
    1. 单个对象
        Person person=JSON.parseObject(jsonStr,Person.class);
    2. 对象的集合
        List<Person> list=JSON.parseArray(jsonStr,Person.class);
    3. 字符串的集合
        List<String> list=JSON.parseArray(jsonStr,String.class);
    4. Map对象的集合
        List<Map<String,Object>> listMap=JSON.parseObject(jsonStr,new TypeRefrence<List<Map<String,Object>>>(){});

字节流

InputStream:字节输入流
    FileInputStream fis=new FileInputStream("temp.txt");
    byte[] arr=new byte[fis.available()]; //fis.available() 获取文件的大小
    int num=fis.read(arr);
    System.out.println(arr,0,num);
    fis.close();
    //和键盘绑定再一起的字节输入流对象
    InputStream is=System.in;
    int num=is.read();
OutputStream:字节输出流的父类
    FileOutputStream fos=new FileOutputStream("temp.txt");
    fos.write("....".getBytes());
    fos.close();
    //指定编码：FileOutputStream("temp.txt","utf-8");

编码与解码：
    编码：
        byte[] getBytes(); //编码  以指定字符集将String编码为byte
        byte[] arr=ss.getBytes();
        byte[] getBytes(Charset charset);
        byte[] arr=ss.getBytes("GBK");

文件：

创建文件的三种形式：
    1. File file=new File("e:\\lzl\\Demo1.java");
    2. File file=new File("e:\\lzl","Demo.java");
    3. File parent=new File("e:\\lzl");
        File file=new File(parent,"Demo1.java");
文件常见操作：
    file.exists();  //判断文件是否存在
    file.createNewFile();  //创建文件
    file.madir();  //创建文件夹
    file.mkdirs();  //创建多级目录
    file.getName();  //得到文件名
    file.getPath();  //得到路径
    file.getParent();  //没有上级目录，返回null

线程池

只有一个线程的线程池对象

ExecutorService es=Executors.newSingleThreadExecutor();

固定个数线程的线程池对象 线程超过了固定的个数，则等待

ExecutorService es=Executors.newFixedThreadPool(2);

缓冲的线程池对象 灵活多变

ExecutorService es=Executor.newCachedThreadPool(3);

创建一个定长线程池，支持定时及周期性任务执行

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
scheduledThreadPool.schedule(new Runnable() {  
       public void run() {  
            System.out.println("delay 3 seconds");  
   }  
}, 3, TimeUnit.SECONDS); 
//让线程池中的线程执行任务
es.executor(thread);