Java语法基础学习DayFifteen（IO续）

一、缓冲流（处理流的一种）

1.作用：可以提高文件操作的效率

2.使用BufferedInputStream和BufferedOutputStream实现非文本文件的复制

特点：flush()方法

代码示例：

        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;
        try{
            //1.提供读入、写入的文件
            File file1 = new File("awsl.jpg");
            File file2 = new File("awysl.jpg");
            //2.创建相应节点流FileInputStream、FileOutputStream
            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);
            //3.将节点流的对象作为形参传到缓冲流的构造器中
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //4.具体的文件复制操作
            byte[] b = new byte[];
            int len;
            while((len = bis.read(b)) != -){
                bos.write(b,,len);
                bos.flush();//把最后一点数据清空出去。
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //关闭流(只需要关闭缓冲流)
            if(bis != null){
                try{
                    bis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(bos != null){
                try{
                    bos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

2.使用BufferedReader和BufferedWriter实现纯文本文件的复制（纯文本文件才使用字符流，doc文件不是纯文本，只能使用字节流）

特点：使用BufferedReader的readLine()方法读取文件的一行

　　　BufferedWriter的flush()方法

代码示例：

        BufferedWriter bw = null;
        BufferedReader br = null;
        try{
            File file1 = new File("hello.txt");
            File file2 = new File("hello2.txt");
            FileReader fr = new FileReader(file1);
            FileWriter fw = new FileWriter(file2);
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);

            String str;
            //使用bufferedReader的readLine()方法读取文件的一行，返回str类型的值。
            while((str = br.readLine()) != null){//注意：读取结束返回null
                bw.write(str);//也可以这么换行：bw.write(str+"\n");
                bw.newLine();//换行
                bw.flush();
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(br != null){
                try{
                    br.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(bw != null){
                try{
                    bw.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

二、转换流（处理流的一种）

1.作用：提供了在字节流和字符流之间的转换；字节流中的数据都是字符时，转换成字符流操作更加高效。

2。代码示例：

解码：字节流 - - ->字符流

编码：字符流 - - ->字节流

        BufferedWriter bw = null;
        BufferedReader br = null;
        try{
            //解码
            File file1 = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file1);
            InputStreamReader isr = new InputStreamReader(fis,"GBK");//按GBK的编码标准转换
            br = new BufferedReader(isr);
            //编码
            File file2 = new File("hello3.txt");
            FileOutputStream fos = new FileOutputStream(file2);
            OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK");
            bw = new BufferedWriter(osw);

            String str;
            while((str = br.readLine()) != null){
                bw.write(str);
                bw.newLine();
                bw.flush();
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(br != null){
                try{
                    br.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(bw != null){
                try{
                    bw.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

三、标准输入输出流

标准的输入流：System.in

标准的输出流：System.out

题目：

　　从键盘输入字符串，要求将读取的整行字符串转成大写输出，然后继续输入操作，直到输入“e”或“exit”时退出程序。

代码：

        BufferedReader br = null;
        try{
            InputStream is = System.in;//System.in返回一个InputStream类型的对象
            InputStreamReader isr = new InputStreamReader(is);
            br = new BufferedReader(isr);

            String str;
            while(true){
                System.out.println("请输入字符串：");
                str = br.readLine();
                if(str.equalsIgnoreCase("e") || str.equalsIgnoreCase("exit")){
                    break;
                }
                String str1 = str.toUpperCase();
                System.out.println(str1);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(br != null){
                try{
                    br.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

四、打印流（处理流的一种）

1.分类

字节流：PrintStream

字符流：PrintWriter

2.代码示例

        FileOutputStream fos = null;
        try{
            fos = new FileOutputStream(new File("print.txt"));
        }catch(IOException e){
            e.printStackTrace();
        }
        //创建打印输出流，设置为自动刷新模式（写入换行符或字节"\n"时都会刷新输出缓冲区
        PrintStream ps = new PrintStream(fos,true);
        if(ps != null){
            System.setOut(ps);//把标准输出流（控制台输出）改为输出到文件
        }
        for(int i = ;i <= ;i++){//输出ASCII字符
            System.out.print((char)i);
            if(i %  == ){
                System.out.println();//每50个数据换行
            }
        }
        ps.close();

五、数据流(处理流的一种）

1.作用

　　为了方便的操作Java语言的基本数据类型、String和字节数组类型的数据，可以使用数据流。

2.特点

DataInputStream和DataOutputStream分别套接在InputStream和OutputStream节点流上。

2.DataOutputStream的使用

注意：输出的物理文件中的内容会变成一堆乱码，需要通过DataInputStream来读取。

        DataOutputStream dos = null;
        try{
            dos = new DataOutputStream(new FileOutputStream(new File("data.txt")));
            dos.writeUTF("我爱你，而你却不知道！");//writeUTF()用来写入String
            dos.writeBoolean(true);
            dos.writeLong();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(dos != null){
                try{
                    dos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

3.DataInputStream的使用

        DataInputStream dis = null;
        try{
            dis = new DataInputStream(new FileInputStream(new File("data.txt")));
            String str = dis.readUTF();
            System.out.println(str);//输出"我爱你，而你却不知道！"
            Boolean b = dis.readBoolean();
            System.out.println(b);//输出true
            Long l = dis.readLong();
            System.out.println(l);//输出310973560
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(dis != null){
                try{
                    dis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

六、对象流（处理流之一）

1.作用

　　用于存储和读取对象的处理流。

2.特点

序列化（Serialize）：用ObejctOutPutStream类将一个Java对象写入IO流中。

反序列化（Deserialize）：用ObjectInputStream类从Io流中恢复该Java对象。

对象的序列化机制：

　　对象的序列化机制允许把内存中的Java对象转换成与平台无关的二进制流，从而允许把这种二进制流持久的保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。

当其他程序获取了二进制流，就可以重新恢复成Java对象。

　　对象支持序列化机制的前提：

　　（1）类需要实现如下两个接口之一：Serializable Externalizable

　　（2）类的属性也要实现Serializable。

　　（3）提供一个版本号：private static final long serialVersionUID

　　（4）使用static和transient关键字修饰的变量不可实现序列化（运行不会报错，但读取出来属性值为null）

3.序列化过程

class Person implements Serializable{
    private static final long SerialVersionUID =  1234561234L;//版本号
    String name;
    Integer age;
    static String ability;//static修饰的变量不可序列化
    Person(String name, Integer age,String ability){
        this.name = name;
        this.age = age;
        this.ability = ability;
    }
    @Override
    public String toString(){
        return "Person[name="+name+",age="+age+",ability="+ability+"]";
    }
}

class Test{
    public static void main(String[] args){

        Person p1 = new Person("小明",,"swimming");
        Person p2 = new Person("超人",,"flying");

        ObjectOutputStream oos = null;
        try{
            oos = new ObjectOutputStream(new FileOutputStream(new File("object.txt")));
            oos.writeObject(p1);
            oos.flush();
            oos.writeObject(p2);
            oos.flush();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(oos != null){
                try{
                    oos.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

4.反序列化过程

class Test{
    public static void main(String[] args){

        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(new FileInputStream(new File("object.txt")));
            Person p1 = (Person)ois.readObject();
            System.out.println(p1);//输出Person[name=小明,age=23,ability=null]
            Person p2 = (Person)ois.readObject();
            System.out.println(p2);//输出Person[name=超人,age=21,ability=null]
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(ois != null){
                try{
                    ois.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

七、RandomAccessFile（处理流）

1. 作用

　　支持“随机访问”的方式，程序可以直接跳到文件的任意位置来读、写文件；

　　支持只访问文件的部分内容；

　　可以向已存在的文件内容后追加内容。

2.特点

创建RandomAccessFile类实例需要指定一个mode参数，指定文件访问模式：

　　r：以只读方式打开

　　rw：可读取、写入

　　rwd：可读取、写入；同步文件内容的更新

　　rws：可读取、写入；同步文件内容和元数据的更新

RandomAccessFile对象包含一个记录指针，标识当前读写处的位置，这个指针可以自由移动。

　　long getFilePointer()：获取文件记录指针的当前位置。

　　void seek(long pos)：将文件记录指针定位到pos位置。

3.文件的读写操作

        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try{
            raf1 = new RandomAccessFile(new File("hello.txt"),"r");//只读方式打开
            raf2 = new RandomAccessFile(new File("hello6.txt"),"rw");//读写方式打开
            byte[] b = new byte[];
            int len;
            while((len = raf1.read(b)) != -){
                raf2.write(b,,len);
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //关闭流
            if(raf1 != null){
                try{
                    raf1.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
            if(raf2 != null){
                try{
                    raf2.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }

4.从任意位置写入数据（会覆盖原有的数据，而不是插入数据）

        RandomAccessFile raf = null;

        try{
            raf = new RandomAccessFile(new File("hello6.txt"),"rw");

            raf.seek();//定位到3的位置，默认在0
            raf.write("haha".getBytes());//原来的数据：The destination is stars and seas!
                                       //写入后的数据：Thehahatination is stars and seas!
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //关闭流
            if(raf != null){
                try{
                    raf.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }

        }

5.从任意位置插入数据，不会覆盖插入位置后面的数据

        RandomAccessFile raf = null;

        try{
            raf = new RandomAccessFile(new File("hello6.txt"),"rw");

            raf.seek();
            byte[] b = new byte[];
            int len;
            StringBuffer sb = new StringBuffer();
            while((len = raf.read(b)) != -){
                sb.append(new String(b,,len));//把要插入的位置后面的数据都读取到sb中。
            }
            raf.seek();
            raf.write("haha ".getBytes());//原来的数据：The destination is stars and seas!
            raf.write(sb.toString().getBytes());//结果：The haha destination is stars and seas!
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //关闭流
            if(raf != null){
                try{
                    raf.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }

        }