Java中输入输出流的理解

IO（Input/Output）:输入和输出，指的是某个设备或环境进行数据的输入或者输出。例如：键盘的输入，再比如显示器就是输出设备，输出图像。

流的分类：

IO流在java中从输入输出角度分类：

         1.输入流

         2.输出流

IO流在java中从数据的角度来分类：

         1.字符流

                   文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等

         2.字节流

                   二进制的数据，这种数据一般用文本打开我们读不懂。比如，图片文件，mp3文件，等等。

字符流：

文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等

字符流

从API的文档我们可以看出：Write有使用abstract修饰。

 方法摘要：

Writer	append(char c)           将指定字符添加到此 writer。
Writer	append(CharSequence csq)           将指定字符序列添加到此 writer。
Writer	append(CharSequence csq, int start, int end)           将指定字符序列的子序列添加到此 writer.Appendable。
abstract  void	close()           关闭此流，但要先刷新它。
abstract  void	flush()           刷新该流的缓冲。
void	write(char[] cbuf)           写入字符数组。
abstract  void	write(char[] cbuf, int off, int len)           写入字符数组的某一部分。
void	write(int c)           写入单个字符。
void	write(String str)           写入字符串。
void	write(String str, int off, int len)           写入字符串的某一部分。

输入流：

同样在Reader中我们可以看出也是有abstract修饰的。

 字符流的命名规则：

　　如果是输出流则以Writer结尾

　　如果是输入流则以Reader结尾

Demo:

package zh.stu;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class IOStu {
    
    public static void main(String[] args){
        // 新建一个文件，向文件中写入一句话
        File file=new File("test.txt");
        Writer writer = null;
        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            writer=new FileWriter(file);
            writer.write("hello");
            
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }
}

向原有的文件中在追加数据

package zh.stu;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class IOStuappend {
    
    public static void main(String[] args) {
        Writer writer=null;
        try {
            writer = new FileWriter("test.txt",true);
            
            writer.write("world");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

换行：

输出换行

         把文本写入文件中 代表换行

         问题是不同的环境下换行的方式也不一样

         Windows:

         Linux:

         Mac:

package zh.stu;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class IOStuLine {
    
    public static void main(String[] args) {
        Writer writer=null;
        try {
            writer = new FileWriter("test.txt",true);
            for(int i=1;  i<100; i++){
                writer.write("world
");
                // 每次写入十个的时候都要做一次flush
                if(i%10==0){writer.flush();}
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 BufferReader的使用：高效缓冲字符输入流

package zh.stu.Buffered;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class bufferedReader {
    
    public static void main(String[] args) {
        BufferedReader buff=null;
        try {
            // 创建一个高效的缓冲输入流
            buff=new BufferedReader(new FileReader("test.txt"));
            String lineContent=null;
            // 读取没一行数据，直到全部读取
            while((lineContent = buff.readLine()) != null){
                System.out.println(lineContent);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (buff != null){
                try {
                    buff.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedWriter的使用，高速缓冲字符输出流。新建一个文件，并向这个文件中写入数据。

package zh.stu.Buffered;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class bufferedWriter {
    
    public static void main(String[] args) throws IOException {
        BufferedWriter writer=null;
        try {
            writer=new BufferedWriter(new FileWriter("bffWriter.txt"));
            // 向文件中写入数据
            for(int i=0; i<10; i++){
                writer.write("hello");
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (writer != null){
                writer.close();
            }
        }
    }
}

使用BufferedWriter和BufferedReader实现文件的拷贝

package zh.stu.Buffered;

import java.io.*;

public class CopyByBuffered {
    
    public static void main(String[] args) {
        BufferedReader reader=null;
        BufferedWriter writer=null;
        try {
            String line=null;
            // 高速缓冲输入流
            reader=new BufferedReader(new FileReader("bffWriter.txt"));
            // 将读取到的数据使用writer写入另外一个文件中
            // 高速缓冲输出流
            writer=new BufferedWriter(new FileWriter("test.txt"));
            while ((line = reader.readLine()) != null){
                writer.write(line);
                writer.newLine();
                writer.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if (writer !=null){
                    writer.close();
                }
                if (reader != null){
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 字节流

字节输入流：InputStream:常用子类：FileInputStream

字节输出流：OutputStream:常用的子类：FileOutputStream

当使用OutputStream时候向一个文件中添加数据

package zh.stu.ByteStream;

import java.io.*;

public class OutPutStreamTest {
    
    public static void main(String[] args) {
        OutputStream out=null;
        try {
            byte [] Num={97,99,55};
            out=new FileOutputStream(new File("output.txt"));
            out.write(Num);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这个时候我们可以看出，输入到文件中的数据是经过编码之后的数据。

ac7

使用InputStream读取OutputStream存的数据

package zh.stu.ByteStream;

import java.io.*;

public class InputStreamTest {
    
    public static void main(String[] args) {
        InputStream in=null;
    
        try {
            // 创建一个字节的数组
            byte[] bytes = new byte[1024];
            // 创建字符输入流的对象，如果有中文则可能出现乱码的情况
            in=new FileInputStream(new File("output.txt"));
            // 定义读取到的标识
            int len=-1;
            while ((len = in.read(bytes)) != -1){
                String s = new String(bytes, 0, len);
                System.out.println(s);
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 使用字符的高效缓冲复制一张图片到另外一个文件夹

package cn.tx.buffer;

import java.io.*;

public class BufferCopy {

    public static void main(String[] args) {
        //定义一个高效缓存字节流
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        try {
            //创建一个高效缓存字节流对象
            in = new BufferedInputStream(new FileInputStream("D:/feiji.jpg"));
            out = new BufferedOutputStream(new FileOutputStream("plane.jpg"));
            //定义一个字节数组
            byte[] bs = new byte[1024];
            //定义一个标志
            int len = -1;
            while((len = in.read(bs)) != -1){
                out.write(bs, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(out != null){
                    out.close();
                }
                if(in != null){
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流和字节流的转换桥梁

OutputStreamWriter是字符流通向字节流的桥梁

字符流通向字节流桥梁InputStreamReader