输入和输出(二)

输入和输出(二)

Reader类

常用方法

1. int read( )
2. int read(char[] c)
3. read(char[] c,int off,int len)
4. void close( )

子类InputStreamReader常用的构造方法

InputStreamReader(InputStream in)
InputStreamReader(InputStream in,String charsetName)

FileReader类

FileReader类是InputStreamReader的子类

FileReader(File file)
FileReader(String name)

该类只能按照本地平台的字符编码来读取数据，用户不能指定其他的字符编码类型

使用FileReader读取文件的步骤：
1、引入相关的类
如:import java.io.Reader;
2、创建FileReader对象
如：Reader fr= new FileReader("D:\\myDoc\\简介.txt");
3、读取文本文件的数据
如：fr.read();
4、关闭相关的流对象
如：fr.close();

BufferedReader类

定义：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取

使用FileReader类和BufferReader类可以提高字符流读取文本文件的效率

BufferedReader常用的构造方法：

BufferedReader(Reader in)

子类BufferedReader特有的方法

 readLine();

注：BufferedReader类是Reader类的子类
BufferedReader类带有缓冲区
使用 BufferedReader读文本文件的步骤：
1、引入相关的类
如：import java.io.FileReader;
2、构造BufferedReader对象和FileReader对象
如：BufferedReader br=new BufferedReader(fr);
3、调用readLine()方法读取数据
如：br.readLine();
4、关闭文件流对象
如：br.close();

读取中文时乱码的处理方法：

FileInputStream fis=new FileInputStream("c:/myDoc/hello.txt");
//使用InputStreamReader并设置编码格式
InputStreamReader fr=new InputStreamReader(fis,"UTF-8"); 
BufferedReader br=new BufferedReader(fr); 

Writer类

常用方法：

1. write(String str)
2. write(String str,int off,int len)
3. void close()
4. void flush()

子类OutputStreamWriter常用的构造方法

OutputStreamWriter(OutputStream out)
OutputStreamWriter(OutputStream out,String charsetName)

FileWriter类

FileWriter类是OutputStreamWriter的子类

FileWriter (File file)
FileWriter (String name)

该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型

使用FileWriter写文件的步骤：
1、引入相关的类
如：import java.io.Reader;
2、创建FileReader对象
如：Writer fw= new FileWriter("D:\\myDoc\\简介.txt");
3、写文本文件
如：fw.write();
4、关闭相关的流对象
如：fw.close();

BufferedWriter类

使用FileWriter类与BufferedWriter类可以提高字符流写文本文件的效率

BufferedWriter常用的构造方法：

 BufferedWriter(Writer out)

注：BufferedWriter常用的构造方法
BufferedWriter(Writer out)

使用 BufferedWriter写文件的步骤：
1、引用相关的类
如：import java.io.FileWriter ;
2、构造BufferedWriter对象和FileWriter对象
如：BufferedWriter bw=new BufferedWriter(fw);
3、调用write()方法写数据
如：bw.write("hello");
4、流对象的清空和关闭flush()和close()
如：bw.flush(); fw.close();

练习1：替换文本文件内容
需求说明：按照刚才读取的模板文件pet. template的模板格式保存宠物数据到文本文件，即把{name}、{type}、{master}替换为具体的宠物信息，将替换后的内容写入到C:\myDoc\pet.txt中

public class Pc1 {
    public static void main(String[] args) {
        //输入流读取
        BufferedReader br = null;
        InputStreamReader ir = null;
        FileInputStream fis = null;
        //输出流读取
        BufferedWriter bw=null;
        FileWriter fw=null;
        try {
            //从源文件中读取
            fis = new FileInputStream("E:/players/pet.txt");
            ir = new InputStreamReader(fis, "utf-8");
            br = new BufferedReader(ir);
            StringBuffer sbf=new StringBuffer();
            String line = null;
            while ((line = br.readLine()) != null) {
                sbf.append(line);
            }
            System.out.println("替换前："+sbf);
            //文件内容替换
            String newStr=sbf.toString().replace("name","欧欧").replace("type","狗狗").replace("master","李伟");
//            String newStr1=sbf.toString().replace("name","欧欧");
//            String newStr2=sbf.toString().replace("tyre","狗狗");
//            String newStr3=sbf.toString().replace("master","李伟");
            System.out.println("替换后："+newStr);
            //将替换后的新内容写入新文件
            fw=new FileWriter("E:/players/pet.txt");
            bw=new BufferedWriter(fw);
            bw.write(newStr);
            bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
                ir.close();
                fis.close();
                bw.close();
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如下：

二进制文件读写

DataInputStream类
1、FileInputStream的子类
2、与FileInputStream类结合使用读取二进制文件

DataOutputStream类
1、FileOutputStream的子类
2、与FileOutputStream类结合使用写二进制文件

使用Data读写二进制文件步骤：
1、引用相关的类
2、构造数据输入/输出流对象
3、调用read()/write()方法读取/写二进制数据
4、关闭数据输入流

练习2：复制图片
需求说明：图片preview.jpg位于E盘根目录下，要求将此图片复制到E:/download/newpreview.jpg

public class Pc2 {
    public static void main(String[] args) {
        //输入流
        DataInputStream dis=null;
        FileInputStream fis=null;
        //输出流
        DataOutputStream dos=null;
        FileOutputStream fos=null;
        try{
            fis=new FileInputStream("E:/players/preview.jpg");
            dis=new DataInputStream(fis);

            fos=new FileOutputStream("E:/download/newpreview.jpg");
            dos=new DataOutputStream(fos);

            int temp;
            while((temp=dis.read())!=-1){
                dos.write(temp);
            }
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                dos.close();
                fos.close();
                dis.close();
                fis.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

序列化和反序列化

定义：
序列化是将对象的状态写入到特定的流中的过程
反序列化则是从特定的流中获取数据重新构建对象的过程

序列化与反序列化使用场景：
场景一：内存对象需要在其它环境下使用
两个进程间进行网络通信时，无论是发送何种类型的数据，均需以二进制序列形式进行传送
1、发送方必须将数据对象（比如Java对象）转化为字节序列
2、接收方则需要将接收到的字节序列再还原成Java对象

场景二：内存对象需要在将来某个时间使用
将内存中的数据对象永久存储在磁盘中（持久化）

常用序列化方案：

序列化和反序列化的过程：

序列化和反序列化的步骤：
1、实现serializable接口
2、创建对象输出流/输入流
3、调用writeObject()方法将对象写入文件/readObject()方法读取对象
4、关闭对象输出流/输入流

注：使用集合保存对象，可以将集合中的所有对象序列化
如果向文件中使用序列化机制写入多个对象，那么反序列化恢复对象时，必须按照写入的顺序读取

练习3：学员对象的序列化和反序列化

public class Student implements Serializable {
    private String name;
    private int age;
    private String gender;
    private transient String password;

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Student(String name, int age, String gender, String password) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.password = password;
    }

    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;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

public class TestStudent {
    public static void main(String[] args) {
        Student stu = new Student("小红", 18, "女", "123456");
        //对象输出化
        ObjectOutputStream oos = null;
        FileOutputStream fos = null;
        //对象的输入流
        ObjectInputStream ois=null;
        FileInputStream fis=null;
        try {
            //序列化
            fos = new FileOutputStream("E:/players/Student.txt");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(stu);
            //反序列化
            fis=new FileInputStream("E:/players/Student.txt");
            ois=new ObjectInputStream(fis);
            Student stu1=(Student)ois.readObject();
            System.out.println("反序列化后的信息是："+stu1.getName()+"-"+stu1.getAge()+"-"+stu1.getGender()+"-"+stu1.getPassword());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        } finally {
            try {
                oos.close();
                fos.close();
                ois.close();
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}