IO流的简单学习

IO流

​ IO：输入/输出(Input/Output)

​ 流：对数据传输的抽象说法。

​ IO流：用来处理设备间数据的传输问题 eg：文件复制、文件上传、文件下载

分类

​ 数据的流向： 输入流、输出流

​ 数据类型：字节流、字符流

字节流

abstract class InputStream 		//字节输入流的超类
abstract class OutPutStream  	//字节输出流的超类
    class FileOutputStram 		//将数据写入File或FileDescriptor的输出流

eg:

public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\java.txt");
        /*
            new时做哪些过程：
                1.调用系统功能创建文件
                2.创建字节输出流对象
                3.让字节输出流指向已创建好的对象
         */
        fileOutputStream.write(97);

        //与IO流相关的，都需要释放资源
        fileOutputStream.close();
    }

写入数据的方式（输出流）

void write(int b)						//就指定的字节写入该文件输出流、一次写一个字节数据
void write(byte[] b)					//将指定的字节数组写入此文件输出流
void write(byte[] b,int off,int len)	//从指定的字节数组开始以len字节，从off位置开始写入此输出流

eg：

public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\java.txt");

        fileOutputStream.write(97); //a


        FileOutputStream fByte = new FileOutputStream("D:\\javaByte.txt");
        byte[] bytes = {97,98,99};
        fByte.write(bytes); //abc


        FileOutputStream fBytes = new FileOutputStream("D:\\javaBytes.txt");
        byte[] bytesLen = {97,98,99,100,101};
        fBytes.write(bytesLen,1,3); //bcd


        fileOutputStream.close();
        fByte.close();
        fBytes.close();
    }

如何换行：

​ window：\r\n linux:\n mac:\r

public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\java.txt");

        for (int i = 0; i < 10; i++) {
            fileOutputStream.write("hello".getBytes());
            fileOutputStream.write("\r\n".getBytes());
        }

        fileOutputStream.close();

    }

如何追加写入：

​ 通过构造方法

FileOutputStream(String name,boolean append) //创建文件输出流以指定的名称写入文件

eg：

public static void main(String[] args) throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\java.txt",true);

        fileOutputStream.write("hei".getBytes());
        fileOutputStream.write("\r\n".getBytes());


        fileOutputStream.close();
    }

读数据（输入流）

    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\java.txt");
//        byte[] bys = new  byte[10];
//
//        int len = fis.read(bys);
//        System.out.println(len);//10 读到的个数
//        System.out.println(new String(bys)); //hello /r/n hel

        byte[] bytes = new byte[1024]; //1024及其整数倍
        int len;
        while ((len = fis.read(bytes))!=-1) { //当fis.read(..) == -1 时 说明文件内容已读完
            System.out.println(new String(bytes,0,len));
        }
        fis.close();
    }

字节缓冲流

class BufferedOutputStream //设置这样的输出流、可以向底层写入字节、而不必每次写入都调用系统
class BufferInputStream		//更高效

构方：

BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out , int size)
BufferInputStream(InputStream in)

注：字节缓冲流 仅仅是提供缓冲区，而读写还是得依赖字节流

eg：

    public static void main(String[] args) throws IOException {
    //先进行输出流再进行输入流
//        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:\\java.txt"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\java.txt"));

//        bos.write("hello".getBytes());

        int by;
        while((by = bis.read())!=-1){
            System.out.print((char)by); //hello
        }


        bis.close();
//        bos.close();

    }

字符流

​ 由于字节流不便于操作中文。于是Java提供字符流。

字符流 = 字节流 + 编码表 【汉字存储时，都让第一个字节处于负数】

InputStramReader		//字符输入流
OutputStreamWriter		//字符输出流

构造方法

OutputStreamWriter(OutputStream out)						//使用默认字符编码
OutputStreamWriter(OutputStream out,String charsetName)		//使用指定的字符编码

InputStramReader(InputStramReader in)
InputStramReader(InputStramReader in,String charsetName)	

eg：

 public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\\java.txt");
        OutputStreamWriter ops = new OutputStreamWriter(fos);

        ops.write("学习");
        ops.close();

        FileInputStream fis = new FileInputStream("D:\\java.txt");
        InputStreamReader isr = new InputStreamReader(fis);

        int ch;
        while ((ch = isr.read())!=-1)
            System.out.print((char)ch);
        isr.close(); //学习
    }

写数据

void write(int c)							//写入一个字符
void write(char[] cbuf)						//写入一个字符数组
void write(char[] cbuf,int off,int len)		//写入字符数组的一部分
void write(String str)						//写入一个字符串
void write(String,int off,int len)			//写入一个字符串的一部分

eg：

public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\java.txt"));

        osw.write(97); //a

        osw.flush();    //刷新流,字符流相对于字节流有个缓冲区

        char[] chars = {'a','b','c'};
        osw.write(chars); //abc
        osw.flush();

        String str = "wow";
        osw.write(str); //wow
        osw.flush();

        osw.close();
    }

读数据

int read()				//一次读一个字符数据
int read(char[] cbuf)	//一次读一个字符数组数据

eg：

  public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\java.txt"));

//        int ch;
//        while ((ch=isr.read())!=-1){
//            System.out.print((char)ch); //wow
//        }

        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs))!= -1){
            System.out.print(new String(chs,0,len)); //wow
        }

        isr.close();
    }

字符缓冲流

BufferedReader //高效读取
BufferedWriter 

public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\java.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("hello");//hello
        bw.close();

        FileReader fr = new FileReader("D:\\java.txt");
        BufferedReader br = new BufferedReader(fr);

        char[] chars = new char[1024];
        int len;
        while((len = br.read(chars))!=-1)
            System.out.print(new String(chars)); //hello

        br.close();
    }

特有功能

BufferedWriter
	void newLine()	//写一行分隔符
BufferedReader
	public String readLint()	//读一行文字，读完了为null

eg：

public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("D:\\java.txt");
        BufferedWriter bw = new BufferedWriter(fw);

        bw.write("hello");//hello
        bw.newLine();
        bw.write("World");
        bw.close();

        FileReader fr = new FileReader("D:\\java.txt");
        BufferedReader br = new BufferedReader(fr);

        String line;
        while ((line = br.readLine())!=null)
            System.out.println(line);
        /*
            hello
            World
         */

        br.close();
    }