java高级编程之IO流

1.流的分类

        1.1按流向分类

                分为输入流和输出流

        1.2按流角色分类

                分为节点流和处理流

        1.3按数据单位分类

                分为字符流和字节流

2.流的四个抽象基类

        InputStream、OutputStream、Reader、Writer

3.四个基本节点流

        FileInputStream、FileOutputStream、FileReader、FileWriter

4.四个基本的缓冲流

        BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

5.两个基本的转换流

        InputStreamReader、OutPutStreamWriter

6.流的使用

        6.1 FileInputStream和FileOutputStream的使用(实现照片的复制)

package com.atguigu.java;

import org.junit.Test;

import java.io.*;

public class FileInputOutputStreamTest {
    @Test
    public void text()  {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try{
           // 1.造文件
           File srcFile = new File("huang.jpg");
           File destFile = new File("huang1.jpg");
           // 2.造流
                fileInputStream = new FileInputStream(srcFile);
                fileOutputStream = new FileOutputStream(destFile);
           // 3.流相关操作
           byte[] bytes =new byte[5];
           int len;
           while((len = fileInputStream.read(bytes)) != -1 ){
               fileOutputStream.write(bytes,0,len);
           }

       }catch (Exception e){
           e.printStackTrace();
       }finally {
            // 4.关流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fileOutputStream != null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
       }


    }
}

        6.2 FileReader和FileWriter的使用(实现文本文件的复制)

package com.atguigu.java;

import org.junit.Test;

import java.io.*;

public class FileInputOutputTest { @Test
    public void testFileReaderWriter()  {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
       try{
           // 1.创建两个文件对象
           File srcFile = new File("hello.txt");
           File destFile = new File("hello2.txt");
           // 2.创建两个流，用于传递数据
                 fileReader = new FileReader(srcFile);
                 fileWriter = new FileWriter(destFile);
           // 3.相关流对应的操作
           char[] chars =new char[5];
           int len;
           while((len = (fileReader.read(chars))) != -1){
               fileWriter.write(chars,0,len);
           }
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           // 4.流的关闭
          if(fileReader != null){
              try {
                  fileReader.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }

       }
        if(fileWriter != null){
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

        6.3四个缓冲流的使用

                缓冲流的使用过程与节点流的使用过程极其相似，相较于节点流，其复制速度显著加快，对大容量的文件其效果更为显著

package com.atguigu.java;

import org.junit.Test;

import java.io.*;

public class BufferedTest {
    @Test
    public void testBuffered() throws IOException {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
       try{
           // 1.造文件
           File srcFile = new File("huang.jpg");
           File destFile = new File("huang2.jpg");
           // 2.造流
            fileInputStream = new FileInputStream(srcFile);
            fileOutputStream = new FileOutputStream(destFile);
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
           // 3.复制的一些细节
           byte[] bytes = new byte[10];
           int len;
           while((len = bufferedInputStream.read(bytes)) !=-1){
               bufferedOutputStream.write(bytes,0,len);
           }
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           // 4.关闭资源
           bufferedInputStream.close();
           bufferedOutputStream.close();
       }




    }
    public void copyFileWithBuffered(String srcPath, String destPath){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try{
            // 1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            // 2.造流
            fileInputStream = new FileInputStream(srcFile);
            fileOutputStream = new FileOutputStream(destFile);
            bufferedInputStream = new BufferedInputStream(fileInputStream);
            bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            // 3.复制的一些细节
            byte[] bytes = new byte[10];
            int len;
            while((len = bufferedInputStream.read(bytes)) !=-1){
                bufferedOutputStream.write(bytes,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 4.关闭资源
            if(bufferedInputStream != null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
           if(bufferedOutputStream != null){
               try {
                   bufferedOutputStream.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }



    }
    @Test
    public void testCopyFileWithBuffered(){
        String srcPath = "C:\\jianpianDownload\\贝尔·格里尔斯：险境逃生第1集冒险者逃生.mp4";
        String destPath = "C:\\jianpianDownload\\贝尔·格里尔斯：险境逃生第1集冒险者逃生2.mp4";
        long start = System.currentTimeMillis();
        copyFileWithBuffered(srcPath,destPath);
        long end = System.currentTimeMillis();
        System.out.println("复制所花的时间为："+(end-start));


    }
    @Test
    public void testBufferedReaderWriter(){
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try{
            // 1.建文件，创流
             bufferedReader = new BufferedReader(new FileReader(new File("hello.txt")));
             bufferedWriter = new BufferedWriter(new FileWriter(new File("hello3.txt")));
            // 2.复制的细节
//            char[] chars =new char[5];
//            int len;
//            while((len = bufferedReader.read(chars)) != -1){
//                bufferedWriter.write(chars,0,len);
//
//            }
            // 方式2：使用String
            String data;
            while((data = bufferedReader.readLine()) != null){
                bufferedWriter.write(data);
                bufferedWriter.newLine();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 3.关流
            if (bufferedReader != null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bufferedWriter != null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }





    }
}

        6.4 转换流的使用

package com.atguigu.java;

import org.junit.Test;

import java.io.*;

public class InputStreamReaderTest {
    /*
    转换流的使用
     */

    @Test
    public void test() throws Exception{
        FileInputStream fileInputStream = new FileInputStream("java.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
        char[] chars = new char[30];
        int len;
        while((len = inputStreamReader.read(chars)) != -1){

            String str = new String(chars,0,len);
            System.out.println(str);

        }


    }

    @Test
    public void test1() throws Exception{
        // 1.造文件，造流
        FileInputStream fileInputStream = new FileInputStream("java.txt");
        FileOutputStream fileOutputStream = new FileOutputStream("java1.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"gbk");
        // 2.复制过程
        char[] chars =new char[10];
        int len;
        while((len = inputStreamReader.read(chars)) != -1){
            outputStreamWriter.write(chars,0,len);
        }
        inputStreamReader.close();
        outputStreamWriter.close();

    }

    public static void main(String[] args) throws IOException {

            InputStreamReader inputStreamReader = new InputStreamReader(System.in);
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

            while(true){
                System.out.println("请输入一段字符串：");
                String date = bufferedReader.readLine();
                if("e".equalsIgnoreCase(date) || "E".equalsIgnoreCase(date)){
                    System.out.println("程序结束");
                    break;
                }
                String str = date.toUpperCase();
                System.out.println(str);

            }


            bufferedReader.close();
        }
    }

7.对象序列化机制

        7.1概念

                序列化：将java对象转换成与平台无关的二进制流，并存储在磁盘上

                反序列化：将磁盘上的二进制流还原为内存中的java对象

        7.2序列化所需要的条件

                1.实现Serializable接口

                2.有唯一的序列号

                3.可序列化类中的基本类型也要是可序列化的

                4.ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员