文件操作

一、File类

File类：主要用来创建文件或者目录，它位于java.io.File包中
主要方法:
　　返回类型　　　　方法
　 boolean 　　createNewFile()//用于创建一个新文件,不创建目录
　　boolean 　　mkdir()//用于创建一个新目录
　　boolean　　 mkdirs()//用于创建多级目录
　　String 　　 getName()//获取文件的文件名
　　String 　　 getAbsolutePath()//获取文件的绝对路径
　　long 　　 length()//返回文件长度，文件大小以字节单位

例子:

　　(1)创建单个文件夹目录(file.mkdir())

package com.file.demo;
import java.io.File;
public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            file.mkdir();
        }
    }
}

　　(2)创建多个文件夹目录(file.mkdis())

package com.file.demo;
import java.io.File;
public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            file.mkdirs();
        }
    }
}

　　(3)创建一个新文件

package com.file.demo;
import java.io.File;
import java.io.IOException;
public class fileTest {
    public static void main(String[] args) { 
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误 
            } catch (IOException e) {    
                e.printStackTrace();
            }
        }
    }
}

　　(4)获取文件的名字、文件的绝对路径、文件长度（文件大小以字节单位）

package com.file.demo;
import java.io.File;
import java.io.IOException;
public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String fileName = file.getName();//获取文件的名字
        String absolutePath = file.getAbsolutePath();//获取文件的绝对路径
        long length = file.length();//获取文件的长度,如果里面没有内容,则长度为0
        System.out.println("文件的名字为:"+fileName+"\n文件的绝对路径为:"+absolutePath+"\n文件的长度为:"+length);
    }
}

二、IO流

I:Input

O:Outpt

文件:文件夹、具体的文件夹

　　根据File路径来实例化具体的对象

　　文件可以做的事情:获取文件的名字、路径、绝对路径、创建路径、判断文件是否存在、创建文件等（更多的功能可查看File的API）

　　文件的缺陷:不能够读取具体文件的内容（由此引入了流的概念）

三、流的概念

1、流的分类

（1）根据文件的流向:输入流、输出流

输入流：从文件————>控制台、程序（字节处理的单位是byte）

InputStream(抽象类)　　FileInputStream(file(或者是字符串,字符串是路径)) 　　

　　 InputStream is=new FileInputStream();(InputStream是抽象类不能被实例化,所以用其子类对它进行实例化)

　　　　　　字节流(byte)：

　　　　　　　　　　　　　a、一个字节一个字节的读:效率不高、读取中文时易出现乱码

　　　　　　　　　　　　　b、byte[] b=new byte[(int) file.length()];(类型是long,需要的是int类型,所以要强转)

　　　　　　　　　　　　　c、BufferInputStream(InputStream is)(包装InputStream效率不高的流)

　　　　　　字符流(char):

　　　　　　　　　　　　Reader(抽象类)　　FileReader　　BufferReader(读一行)

例子：

1、字节流(byte):xbbxb122(非中文)、图片、音频、视频

（1）将信息从文件———>控制台(InputStream)，一个字节一个字节的读，效率很低

package com.file.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        InputStream is=null;
        try {
            is = new FileInputStream(file);
            int msg = is.read();//一个字节一个字节的读取,效率非常低
            while(msg!=-1){//判断是否读取到最后面
                System.out.print((char)msg);//会输出ascll码表对应的数字,所以要进行转型为字符类型
                msg = is.read();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            if(is!=null){
                try {
                    is.close();//关闭流
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

（2）将信息从文件———>控制台(InputStream)，一个字节一个字节存入到字节数组里并将其转换成字符串类型输出，这种方法效率比上面的高，但还是很低。

package com.file.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        InputStream is=null;
        try {
            is = new FileInputStream(file);
            //字符数组的长度是文件内容的长度,因为byte里面的类型是int,而file.length()类型是long,所以要转换成int类型
            byte[] b=new byte[(int) file.length()];
            is.read(b);
            String msg=new String(b);//将字节数组转换成字符串
            System.out.println(msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            if(is!=null){
                try {
                    is.close();//关闭流
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

（3）将信息从文件———>控制台(InputStream)，一个字节一个字节存入到字节数组里，并将其放到 BufferedInputStream，它是一个带有缓冲区的输入流,它可以提高我们的读取效率，效率最高

package com.file.demo;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        InputStream is=null;
        BufferedInputStream bis=null;
        try {
            is = new FileInputStream(file);
            //字符数组的长度是文件内容的长度,因为byte里面的类型是int,而file.length()类型是long,所以要转换成int类型
            byte[] b=new byte[(int) file.length()];
            //BufferedInputStream缓冲区输入流
            bis=new BufferedInputStream(is);
            bis.read(b);
            String msg=new String(b);
            System.out.println(msg);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if(is!=null){
                    is.close();
                }
                if(bis!=null){
                    bis.close();
                }
            } catch (Exception e2) {
                
            }
        }
    }
}

2、字符流(char):纯文字　　将信息从文件———>控制台(Reader)

package com.file.demo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.util.Scanner;

public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Reader read=null;
        BufferedReader br=null;
        try {
            read=new FileReader(file);
            br=new BufferedReader(read);
            //方法一:
            char[] c=new char[(int) file.length()];
            br.read(c);
            System.out.println(c);
            //方法二:
//            String readLine = br.readLine();//读取一整行的内容
//            while(readLine!=null){//判断是否还有信息存在
//                System.out.println(readLine);
//                readLine = br.readLine();
//            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{//关闭流
            try {
                if(br!=null){
                    br.close();
                }
                if(read!=null){
                    read.close();
                }
            } catch (Exception e2) {
                
            }
        }
    }
}

输出流：从控制台————>文件

　　　　　　字节流(byte)：

　　　　　　　　　　　　OutputStream(抽象类)　　FileOutputStream　　BufferOutputStream

　　　　　　　　　　　　例如:String str="中国万岁!"　　将String转换为byte:str.getBytes()

　　　　　　　　　　　　　　 byte[] b 将byte转换为String:String str=new String(b)

　　　　　　字符流(char):

　　　　　　　　　　　　Writer(抽象类)　　FileWriter　　BufferWriter(String str)

例子:

字节流:

（1）将信息从控制台———>文件(OutputStream)，进化跟上面的InputStream一致，所以写一个最高效率的

package com.file.demo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Scanner;

public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Scanner input=new Scanner(System.in);
        System.out.print("请输入您要写的内容:");
        String str=input.next();
        OutputStream os=null;
        BufferedOutputStream bos=null;
        try {
            //true是在原本的内容的基础上进行追加,如果没有加true写入txt的内容会覆盖原本的内容
            os=new FileOutputStream(file,true);
            //将字符转换成字符数组
            byte[] b=str.getBytes();
            bos=new BufferedOutputStream(os);
            bos.write(b);
            // 刷新此缓冲的输出流，这个最好写上，如果写的内容多了，它可能没有写进去
            bos.flush();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{//关闭流
            try {
                if(bos!=null){
                    bos.close();
                }
                if(os!=null){
                    os.close();
                }
            } catch (Exception e2) {
                
            }
        }
    }
}

字符流(char):纯文字　　将信息从控制台———>文件(Writer)

package com.file.demo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.util.Scanner;

public class fileTest {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        if(!file.exists()){//判断文件是否存在,不存在则创建文件
            try {
                file.createNewFile();//前提条件是存在D:\\temp路径才能创建,否则会提示系统找不到指定路径错误
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        Scanner input=new Scanner(System.in);
        System.out.print("请输入您要写的内容:");
        String str=input.next();
        Writer writer=null;
        BufferedWriter bw=null;
        try {
            //true是在原本的内容的基础上进行追加,如果没有加true写入txt的内容会覆盖原本的内容
            writer=new FileWriter(file,true);
            bw=new BufferedWriter(writer);
            //换行的方法
            bw.newLine();
            bw.write(str);
            bw.flush();
        } catch (IOException e) {
            
            e.printStackTrace();
        } finally{//关闭流
            try {
                if(bw!=null){
                    bw.close();
                }
                if(writer!=null){
                    writer.close();
                }
            } catch (Exception e2) {
                
            }
        }
    }
}

（2）根据处理的字节数

　　字节流:xbbxb122(非中文)、图片、音频、视频(byte)

字符流:纯文字(char)

需要将字节流——>字符流:（可设置字符编码,就是设置它的编码个格式）

　　　　　　　　　　　　　　　　输入:InputStreamReader

　　　　　　　　　　　　　　　　输出:OutputStream

例子:将字节流转换成字符流

package com.file.demo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class fileTest {
    public static void main(String[] args) {
        System.out.println("请输入:");
        InputStream in=System.in;
        InputStreamReader isr=null;
        try {
            //"GBK"设置字符编码的格式
            isr=new InputStreamReader(in,"GBK");
        } catch (UnsupportedEncodingException e) {
            
            e.printStackTrace();
        }
        BufferedReader br=new BufferedReader(isr);
        try {
            String str=br.readLine();
            System.out.println(str);
        } catch (IOException e) {
            
            e.printStackTrace();
        } finally{
            try {
                if(br!=null){
                    br.close();
                }
                if(isr!=null){
                    isr.close();
                }
                if(in!=null){
                    in.close();
                }
            } catch (Exception e2) {
                
            }
        }
    }
}

（3）应用
思路:分析题目（输入还是输出、是否是纯文本）
　　　　　a、输入还是输出
　　　　　b、是否是纯文本
　　　　　c、是否高效:默认条件是,结合buffer去用

（4）序列化和反序列化
　　序列化:将对象进行流化写入某个文件中去:ObjectOutputStream(new FileOutputStream())//需要一个流的参数
反序列化:将已经被流化在某个文件中的对象进行恢复（恢复成对象）
输入:ObjectInputStream（new FileInputStream）
序列化步骤:
a、对象必须实现Serializable
注意:序列化接口没有方法或字段,仅用于标识可序列化的语义
建议写一个默认的序列号(因为序列化和反序列化都是根据这个ID进行对接)
b、ObjectOutputStream(new FileOutputStream())
c、oos.writerObject(obj)
d、关闭相关的流

例子:序列化和反序列化

序列化和反序列化公用的Student类

package com.SerializeandDeserialize;

import java.io.Serializable;

public class Student implements Serializable{//序列化和反序列化必须要实现这个接口
    private static final long serialVersionUID = 1L;
    private String id;
    private String name;
    private String phone;
    public Student() {
        super();
    }
    public Student(String id, String name, String phone) {
        super();
        this.id = id;
        this.name = name;
        this.phone = phone;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", phone=" + phone
                + "]";
    }
}

（1）序列化:将对象进行流化写入某个文件中去:ObjectOutputStream(new FileOutputStream())

package com.SerializeandDeserialize;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

public class SerializeDemo {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        Student stu=new Student();
        List<Student> list=new ArrayList<Student>();
        list.add(new Student("1", "小明", "13265498270"));
        list.add(new Student("2", "小灰", "15365894237"));
        list.add(new Student("3","小花","13960279134"));
        OutputStream os=null;
        ObjectOutputStream oos=null;
        //写相应的流进行存储
        try {
            //重点是进行序列化的流是:ObjectOutputStream+FileOutputStream
            os=new FileOutputStream(file,true);
            oos = new ObjectOutputStream(os);
            oos.writeObject(list);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{//关闭流
            try {
                if(oos!=null){
                    oos.close();
                }
                if(os!=null){
                    os.close();
                }
            } catch (Exception e2) {
                
            }
        }
    }
}

（2）反序列化:将已经被流化在某个文件中的对象进行恢复(恢复成对象)

package com.SerializeandDeserialize;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.util.List;

public class DeserializeDemo {
    public static void main(String[] args) {
        String path="D:\\temp\\text.txt";
        File file=new File(path);
        InputStream is=null;
        ObjectInputStream ois=null;
        try {
            is=new FileInputStream(file);
            //真正进行反序列化的类是:ObjectInputStream
            ois=new ObjectInputStream(is);
            Object obj = ois.readObject();
            if(obj!=null){
                List<Student> list=(List<Student>) obj;
                for (Student s : list) {
                    //该输出的是Student的toString方法,如果Student没有toString方法,则会默认调用父类的toString方法
                    System.out.println(s);
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally{//关闭流
            try {
                if(ois!=null){
                    ois.close();
                }
                if(is!=null){
                    is.close();
                }
            } catch (Exception e2) {
            }
        }
    }
}

四、反射机制的使用

（1）Class:类
（2）Field:属性
（3）Method:方法
（4）Constractor:构造方法
　　类的组成:属性、构造方法、方法、块、静态块、内部类

Class类方法
1、getFields() 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
2、Object obj=cls.newInstance();//相当于Object obj=new User();前提要有构造方法才可以使用
3、Constructor cons=cls.getConstructor(new Class[]{Integer.class,String.class});//构造方法的声明
Object obj=cons.newInstance(new Object[]{1,"xgr"});//相当于Object obj=new User(1,"xgr");

五、xml文件解析以及xml文件的读取、写入

1、xml的特点：

　　　　　　　　第一：文档的申明<?xml version="1.0" encoding="utf-8">

　　　　　　　　第二：根节点一个

　　　　　　　　第三：标签成对出现：正确的嵌套

一个标准的xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<school>
<class id="1"></class>
<name>初三三班</name>
<teacher>朱老师</teacher>
</school>

2、dtd验证文件：(主要是为了约束xml)

　两种形式:内嵌形式：

　　　　　　　　　　　<!DOCTYPE 根节点[

..........................

内嵌套形式例子:school.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE school[
<!ELEMENT school (class+)>
<!ELEMENT class (name?,teacher+)>
<!ATTLIST class id CDATA #REQUIRED>
<!ELEMENT name (#PCDATA)>
<!ELEMENT teacher (#PCDATA)>
]>

<school>
<class id="1">
<name>初三二班</name>
<teacher>小猪</teacher>
</class>
<class id="2">
<name>高一五班</name>
<teacher>小凡</teacher>
</class>
</school>

外联形式：（单独的的dtd文件）

　　　　　　　　　　 <!DOCTYPE 根节点 SYSTEM "xxxx.dtd">

外联形式例子:school.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE school SYSTEM "school.dtd">
<school>
<class id="1">
<name>初三二班</name>
<teacher>小猪</teacher>
</class>
<class id="2">
<name>高一五班</name>
<teacher>小凡</teacher>
</class>
</school>

school.dtd

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT school (class+)>
<!ELEMENT class (name?,teacher+)>
<!ATTLIST class id CDATA #REQUIRED>
<!ELEMENT name (#PCDATA)>
<!ELEMENT teacher (#PCDATA)>

符号的使用:

　　　　　　　?————表示相同变量名有0-1个

　　　　　　 +————表示相同变量名可以有1-N个

　　　　　　 *————表示相同变量名可以有0-N个

　　　不写符号————表示变量名只有唯一一个

3、Dom解析(xml解析)

思路：a、创建一个解析器工厂

b、生成一个解析器

c、解析文件

d、进行相应功能的操作

（以下步骤是需要进行保存更新修改使用的）

f、创建一个转换工厂

g、生成一个转换器

h、转换文件

　　　I、写测试类,测试所写的方法功能是否可行(必须写)

例子:

目录截图:

(1)创建school.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE school SYSTEM "school.dtd">
<school>
<class id="1">
<name>初三二班</name>
<teacher>小明</teacher>
</class>
</school>

(2)创建shcool.dtd文件

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT school (class+)>
<!ELEMENT class (name,teacher)>
<!ATTLIST class id CDATA #REQUIRED>
<!ELEMENT name (#PCDATA)>
<!ELEMENT school (#PCDATA)>

(3)创建实体类entity

package com.dom.demo.entity;

public class Classes {
    
    private String id;//班级编号id
    private String className;//班级姓名
    private String teacher;//班级教师的名字
    
    //无参构造方法
    public Classes() {
        super();
    }

    
    //有参构造方法
    public Classes(String id, String className, String teacher) {
        super();
        this.id = id;
        this.className = className;
        this.teacher = teacher;
    }

    @Override
    public String toString() {
        return "Classes [id=" + id + ", className=" + className + ", teacher="
                + teacher + "]";
    }    

}

(4)创建SchoolDao接口

package com.dom.demo.dao;

import java.util.List;

import com.dom.demo.entity.Classes;

public interface SchoolDao {
    
    //增加一条数据:添加有两种情况,成功:true,失败:false
    //添加一条数据就是添加一个Classes对象
    public boolean add(Classes cls);
    
    //删除一条数据:根据id来删除,成功:true,失败:false 
    public boolean delete(int id);
    
    //修改一条数据:根据id来修改,成功:true,失败:false 
    public boolean update(int id,Classes cls);
    
    //查询所有的数据
    public List<Classes> findAll();
    
    //根据id(属性)去查询特定的数据
    public Classes findById(int id);
}

(5)创建SchoolDaoImpl类来实现这个接口

package com.dom.demo.Impl;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.dom.demo.dao.SchoolDao;
import com.dom.demo.entity.Classes;

public class SchoolDaoImpl implements SchoolDao{
    String path="src/com/dom/demo/database/school.xml";

    //添加信息到xml文件中
    @Override
    public boolean add(Classes cls) {
        //获取一个Document
        Document doc=getDocument();
        //获取根节点
        Element root = doc.getDocumentElement();
        //创建指定类型的元素,创建class节点
        Element eClass = doc.createElement("class");
        //将int的类型转换成String类型,因为第二个参数的类型必须是String
        eClass.setAttribute("id", String.valueOf(cls.getId()));
                
        Element name=doc.createElement("name");
        //设计name属性里面的内容
        name.setTextContent(cls.getClassName());
        //将该节点加到eClass的节点上,成为eClass的子节点
        //这里的name发生了自动转型,appendChild里面的参数是Node类型的,但name是Element类型的
        //所以进行了向上转型,向上转型是可以自动转型的
        eClass.appendChild(name);
        
        Element teacher=doc.createElement("teacher");
        teacher.setTextContent(cls.getTeacher());
        //将teacher节点添加到eClass节点上
        eClass.appendChild(teacher);
        
        //将eClass节点添加到根节点上
        root.appendChild(eClass);
        if(save(doc)){
            return  true;
        }
        return false;
    }

    //通过id来删除id这个节点里面的内容
    @Override
    public boolean delete(int id) {
        //获取一个Document
        Document doc = getDocument();
        //获取根节点
        Element root = doc.getDocumentElement();
        //获取根节点的子节点
        NodeList rootChild = root.getChildNodes();
        //遍历孩子节点
        for (int i = 0; i < rootChild.getLength(); i++) {
            //获取孩子节点里面的内容,去到class
            Node son = rootChild.item(i);
            //排除"#text"的情况
            if(!son.getNodeName().equals("#text")){
                //获取class里面的id,只能通过Element里面的方法来获取
                Element eson=(Element)son;
                String sid = eson.getAttribute("id");
                //判断当前的id是否跟输入的id一致
                if(sid.equals(String.valueOf(id))){
                    //删除对应的class的方法是:先找到自己的父节点,然后用父节点把自己给删除
                    son.getParentNode().removeChild(son);
                    //由于以上的操作只保存到缓存中,所以我们应该让它保存到xml文件中
                    if(save(doc)){
                        return true;
                    }
                }        
            }   
        }
        return false;
    }

    //通过id来查找到相应的用户,并将对应的信息进行更新
    @Override
    public boolean update(int id, Classes cls) {
        //获取一个Document
        Document doc = getDocument();
        //获取根节点
        Element root = doc.getDocumentElement();
        //获取根节点的孩子节点
        NodeList rootChild = root.getChildNodes();
        //遍历孩子节点
        for (int i = 0; i < rootChild.getLength(); i++) {
            //获取孩子节点里面的内容,到class
            Node son = rootChild.item(i);
            if(!son.getNodeName().equals("#text")){
                //获取class里面的id进行比较,所以要用Element里面的方法
                Element eson=(Element)son;
                String sid = eson.getAttribute("id");
                //判断当前的id是否与输入的id一致
                if(sid.equals(String.valueOf(id))){
                    NodeList sonson = son.getChildNodes();
                    //遍历孙子节点
                    for (int j = 0; j < sonson.getLength(); j++) {
                        //获取孙在节点里面的内容,去到name和teacher处
                        Node sun = sonson.item(j);
                        if(sun.getNodeName().equals("name")){
                            sun.setTextContent(cls.getClassName());
                        }
                        if(sun.getNodeName().equals("teacher")){
                            sun.setTextContent(cls.getTeacher());
                        }
                    }
                    //由于以上的操作只保存到缓存中,所以我们应该让它保存到xml文件中
                    if(save(doc)){
                        return true;
                    }
                }
            }
            
        }
        return false;
    }

    
    //查询所有的xml文件里面的所有信息
    @Override
    public List<Classes> findAll() {
        //创建List对象,由于List是一个接口,不能进行实例化,所以用它的子类进行实例化
        List<Classes> list=new ArrayList<Classes>();
        Document doc = getDocument();
        //获取根节点
        Element root = doc.getDocumentElement();
        //获取根节点的子节点
        NodeList rootChild = root.getChildNodes();
        //遍历根节点的子节点
        for (int i = 0; i < rootChild.getLength(); i++) {
            //获取根节点的子节点的内容
            //现在去到了class节点,class节点里面有id属性,所以要获取它的id
            Node son = rootChild.item(i);
            //由于输出会存在#text的现象,所以要进行判断
            if(!son.getNodeName().equals("#text")){
                //由于获取属性的方法只存在于Element中,且现在的节点内容是属于Node
                //根据查看Element可以发现,public interface Element extends Node 
                //所以需要将Node转换成Element 向下转型 强转
                Element eson=(Element) son;
                //根据属性的名字获取属性的内容
                String sid = eson.getAttribute("id");
                Classes cls=new Classes();
                //由于cls里面的属性id是整型,而sid是字符串类型,所以要进行类型的强转
                cls.setId(Integer.parseInt(sid));
                //获取孩子节点的下一个节点,即孙子节点
                NodeList sonson = son.getChildNodes();
                //遍历孙子节点
                for (int j = 0; j < sonson.getLength(); j++) {
                    //获取孙节点属性的内容,现在去到name和teacher的那一层里
                    Node sun = sonson.item(j);
                    //判断是name还是teacher,并根据具体的属性来获取相应的内容
                    if(sun.getNodeName().equals("name")){
                        cls.setClassName(sun.getTextContent());
                    }
                    if(sun.getNodeName().equals("teacher")){
                        cls.setTeacher(sun.getTextContent());
                    }
                }
                list.add(cls);
            } 
        }
        return list;
    }

    
    //通过id来获取相应id里面的内容
    @Override
    public Classes findById(int id) {
        //没有进行实例化主要是为了防止占据不必要的空间,如果真正地使用,我们才会进行实例化
        Classes cls=null;
        //获取一个Document
        Document doc = getDocument();
        //获取根节点
        Element root = doc.getDocumentElement();
        //获取根节点的孩子节点
        NodeList rootChild = root.getChildNodes();
        //遍历孩子节点
        for (int i = 0; i < rootChild.getLength(); i++) {
            //获取根节点里面的内容,去到class处
            Node son = rootChild.item(i);
            //判断除去"#text"这些节点
            if(!son.getNodeName().equals("#text")){
                //运用Element来获取class里面的id
                Element eson=(Element)son;
                String sid = eson.getAttribute("id");
                //判断当前的id是否与输入的id一致,若一致则将信息放到Classes中
                if(sid.equals(String.valueOf(id))){
                    cls=new Classes();
                    cls.setId(Integer.parseInt(sid));
                    //寻找孩子节点的下一个节点,即孙子节点
                    NodeList sonson = son.getChildNodes();
                    //遍历孙子节点
                    for (int j = 0; j < sonson.getLength(); j++) {
                        //获取孙在里面的内容,去到了name和teacher处
                        Node sun = sonson.item(j);
                        //判断是否是name和teacher,因为会存在#text,所以要进行判断
                        if(sun.getNodeName().equals("name")){
                            cls.setClassName(sun.getTextContent());
                        }
                        if(sun.getNodeName().equals("teacher")){
                            cls.setTeacher(sun.getTextContent());
                        }
                    }
                    return cls;
                }
            }
        }
        return cls;
    }
    
    //创建解析器工厂——>生成解析器——>解析文件
    public Document getDocument(){
        //第一步:创建一个解析器工厂
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        //第二步:生成解析器
        DocumentBuilder db;
        Document doc = null; 
        try {
            db=dbf.newDocumentBuilder();
            //第三步:解析文件
            File file=new File(path);
            doc = db.parse(file);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return doc;
    }
    
    //主要是进行修改，添加以及删除等功能,对数据进行了操作的话,操作完的数据状态暂时保存在缓存中,如果想同步更改xml文件里面的内容,必须用到这一步 
    public boolean save(Document doc){
        //创建一个转换器工厂
        TransformerFactory tff=TransformerFactory.newInstance();
        //生产一个转换器
        try {
            Transformer tf=tff.newTransformer();
            //doc源
            DOMSource dom=new DOMSource(doc);
            //写入具体的文件的流
            StreamResult sr=new StreamResult(path);
            //实现转换,将DOMSource的dom对象转换为StreamResult的sr对象,dom是要转换的 XML输入,sr转换dom的 Result。
            tf.transform(dom, sr);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return false;
    }
}

(6)为了测试我们的方法是否可行,我们还要写测试类SchoolDaoImplTest

package com.dom.demo.test;


import java.util.List;
import org.junit.Test;
import com.dom.demo.Impl.SchoolDaoImpl;
import com.dom.demo.entity.Classes;

public class SchoolDaoImplTest {
    SchoolDaoImpl dao=new SchoolDaoImpl();

    @Test
    public void testAdd() {
        Classes cls=new Classes();
        cls.setId(5);
        cls.setClassName("高三二班");
        cls.setTeacher("小东");
        dao.add(cls);
    }

    @Test
    public void testDelete() {
        dao.delete(1);
    }

    @Test
    public void testUpdate() {
        Classes cls=new Classes();
        cls.setClassName("高一二班");
        cls.setTeacher("小明");
        dao.update(1, cls);
    }

    @Test
    public void testFindAll() {
        List<Classes> list = dao.findAll();
        for (Classes c : list) {
            System.out.println(c);
        }
    }

    @Test
    public void testFindById() {
        Classes cls = dao.findById(1);
        System.out.println(cls);
    }

}

4、Dom4j解析(xml解析)

思路：　　　

posted @ 2016-08-16 21:07 雪菇阅读(355) 评论(0) 编辑收藏举报

刷新页面返回顶部

雪菇

文件操作

公告