I/O流(总结)

I/O流

1.流的分类

• 按操作数据单位不同分为：字节流(8bit)，字符流(16bit)
• 按数据流的流向不同分为：输入流，输出流
• 按流的角色的不同分为：节点流，处理流

（抽象基类）	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

2.FileReader

文件输入流

import org.junit.Test;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReadWriteTest {

    @Test
    public void filereadertest() throws IOException {
        //1.实例化file类的对象
        File file = new File("hello.txt");
        //2.提供具体的流
        FileReader reader = new FileReader(file);
        //3.数据的读入
        int i = reader.read();
        while (i!=-1){
            System.out.print((char) i);
            i = reader.read();
        }

        reader.close();

    }

    @Test
    public void filereadertest1()  {
        FileReader fileReader = null;
        try {
            //file类的实例化
            File file = new File("hello.txt");
            //filereader流的实例化
            fileReader = new FileReader(file);
            //读入操作
            char[] chars = new char[5];
            int len;
            while ((len=fileReader.read(chars))!=-1){
//                方式一
//                for (int i = 0; i < len; i++) {
//                    System.out.print(chars[i]);
//                }
                
//				  方式二
                String str = new String(chars,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (fileReader!=null){
                try {
                    fileReader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

3.FileWriter

输出操作，对应的File可以不存在的。如果不存在，再输出的时候自动创建。如果存在，如果流使用的构造器是：FileWriter(file,false)或者FileWriter(file)，是对原有文件的覆盖，如果是FileWriter(file,true)则不会对其进行覆盖，在其内容后添加

@Test
public void filewritertest() throws IOException {
    //1.实例化file类的对象
    File file = new File("hello.txt");
    //2.filewriter流的实例化
    FileWriter writer = new FileWriter(file,true);
    //3.写出的操作
    writer.write("混的人\n");
    writer.write("是不是打了\n");
    //4.流的关闭
    writer.close();
}

练习（实现文本的复制）

@Test
public void filereaderwritertest(){
    FileReader fileReader = null;
    FileWriter fileWriter = null;
    try {
        //1.实例化file类的对象
        File in = new File("hello.txt");
        File out = new File("yyh.txt");
        //2.创建输入流和输出流的对象
        fileReader = new FileReader(in);
        fileWriter = new FileWriter(out);
        //3.数据的读入和写出操作
        char[] chars = new char[5];
        int len;
        while ((len = fileReader.read(chars))!=-1){
            fileWriter.write(chars,0,len);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }finally {
        //4.关闭流资源
        if (fileReader!=null&&fileWriter!=null){
            try {
                fileReader.close();
                fileWriter.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

图片不能实现复制

4.InputStream

使用字节流处理文本文件可能会出现乱码

@Test
public void inputstreamfile() throws IOException {
    File file = new File("yyh.txt");
    FileInputStream inputStream = new FileInputStream(file);
    byte[] bytes = new byte[10];
    int len;//每次读取的字节的个数
    while ((len = inputStream.read(bytes))!=-1){
            String str = new String(bytes,0,len);
            System.out.print(str);
    }
    inputStream.close();
}

练习（对图片进行复制）

/**
 * 对图片的复制操作
 */
@Test
public void inputstreamfile1(){
    FileInputStream inputStream = null;
    FileOutputStream outputStream = null;
    try {
        File in = new File("微信.jpg");
        File out = new File("头像.jpg");

        inputStream = new FileInputStream(in);
        outputStream = new FileOutputStream(out);

        byte[] bytes = new byte[5];
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,len);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }finally {
        if (inputStream!=null){
            try {
                inputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        } else if (outputStream!=null) {
            try {
                outputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy {
    public void copyfile(String srcpath , String destpath){

        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            File in = new File(srcpath);
            File out = new File(destpath);

            fileInputStream = new FileInputStream(in);
            fileOutputStream = new FileOutputStream(out);

            byte[] bytes = new byte[5];
            int len;
            while ((len=fileInputStream.read(bytes))!=-1) {
                fileOutputStream.write(bytes,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (fileInputStream!=null&&fileOutputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    @Test
    public void test01(){

        long start = System.currentTimeMillis();

        String srcpath="C:\\Users\\dell\\Desktop\\微信.jpg";
        String destpath="C:\\Users\\dell\\Desktop\\hunao5.jpg";

        copyfile(srcpath,destpath);

        long end = System.currentTimeMillis();
        System.out.println("复制的时间为："+(end-start));

    }
}

5.BufferedInputStream和BufferedOutputStream的使用

读写速度比inputstrean和outputstream更快

import org.junit.Test;
import java.io.*;

public class Bufferedtest {
    /**
     * 缓冲流的使用
     * bufferedinputstream
     * bufferedoutputstream
     * bufferedreader
     * bufferedwriter
     *
     */
    @Test
    public void bufferedstream() throws FileNotFoundException {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            //1.造文件
            File in = new File("2fd5dcc1a7f86d24834628d8b4715fd.jpg");
            File out = new File("yyh.jpg");
            //造流
            inputStream = new FileInputStream(in);
            outputStream = new FileOutputStream(out);

            bufferedInputStream = new BufferedInputStream(inputStream);
            bufferedOutputStream = new BufferedOutputStream(outputStream);

            //读取和写入的过程
            byte[] bytes = new byte[1024];
            int len;
            while ((len=bufferedInputStream.read(bytes))!=-1){
                bufferedOutputStream.write(bytes,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //资源关闭（先关闭外层的流）
            //关闭外层流的同时，内层流也会自动关闭
            if (bufferedInputStream!=null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bufferedOutputStream!=null){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

6.BufferedReader和BufferedWriter的使用

读写速度比reader和writer更快

import org.junit.Test;
import java.io.*;

public class Bufferedwriterreadertest {
    @Test
    public void bufferedwriterreader(){
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            File in = new File("test.txt");
            File out = new File("jxy.txt");

            FileReader reader = new FileReader(in);
            FileWriter writer = new FileWriter(out);

            bufferedReader = new BufferedReader(reader);
            bufferedWriter = new BufferedWriter(writer);

            char[] chars = new char[1024];
            int len;
            while ((len=bufferedReader.read(chars))!=-1){
                bufferedWriter.write(chars,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bufferedWriter!=null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

7.转换流

提供了字节流和字符流之间的转换

javaAPI提供了两个转换流：（都属于字符流）

InputStreamReader:将InputStream转换为Reader

OutputStreamWrite:将Write转换为Outputstream

7.1InputStreamReader的使用

实现字节的输入流到字符的输入流的转换

import org.junit.Test;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Inputstreamreadertest {
    @Test
    public void inputstreamreader(){
        InputStreamReader reader = null;
        try {
            FileInputStream inputStream = new FileInputStream("test.txt");
            reader = new InputStreamReader(inputStream);
            char[] chars = new char[1024];
            int len;
            while ((len=reader.read(chars))!=-1){
                String str = new String(chars,0,len);
                System.out.println(str);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                reader.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

7.2InputStreamReader和OutputStreamWrite的使用

@Test
public void test01(){
    InputStreamReader reader = null;
    OutputStreamWriter writer = null;
    try {
        FileInputStream inputStream = new FileInputStream("test.txt");
        FileOutputStream outputStream = new FileOutputStream("wendu666.txt");

        reader = new InputStreamReader(inputStream,"UTF-8");
        writer = new OutputStreamWriter(outputStream,"UTF-8");

        char[] chars = new char[1024];
        int len;
        while ((len=reader.read(chars))!=-1){
            writer.write(chars,0,len);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }finally {
        if (reader!=null){
            try {
                reader.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        if (writer!=null){
            try {
                writer.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

8.字符集

8.1编码表的由来

计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表，这就是编码表

8.2常见的编码表

• ASCII码 —ASCII编码表由一个字节表示，128个字符，实际上一个字节可以表示256个字符，但是老外的英文只有那么24个字母，用不了那么多的字符。但是随着计算机的普及，全球都在使用计算机，原本的编码不能够满足全球各国语言，所以出现了Unicode。

• Unicode—Unicode编码表是固定大小的编码，使用两个字节来表示字符，字母和汉字统一都是占用两个字节，容易造成空间浪费。

• utf-8—大小可变的编码，字母使用一个字节，汉字使用3个字节。

• gbk—gbk编码可以表示汉字，而且范围广，字母使用一个字节，汉字2个字节。

• gb2312—可以表示汉字，最多两个字节编码所有字符