初学者对于I/O流的小节-上

我是一个刚刚进入java开发的菜鸟，java 基础比较薄弱，面试的路程也经历坎坷。带着这样的心态，我总结了这个关于java io 的文章，肯定覆盖面不全，但是肯定都是最基础最实用的。

第一章 初步认识 输入输出流 I/O流

第一步 流是什么 ？

流是对于信息的一个抽象！

站在程序的角度上讲 输入流 是读取数据
站在程序的角度上讲 输出流 是写入数据

第二步 流 分两种

（1）字节流 用于译字节为单位的输入输出，主要是用于处理 图形声音文件
InputStream 这是所有字节输入流的 父类
OutputStream 这是所有字节输出流的 父类
（2）字符流 以字符为基本处理的单位 ，主要用于处理文本类型文件
Reader这是所有字节输入流的 父类
Writer这是所有字节输出流的 父类

第三步 操作文件

File 类 它既可以代表一个资源文件 也可以代表一个文件夹！
介绍几个常用的方法 getPath() getName() isFile() exists() createNewFile() mkdir()
对于文件的方法可以对文件进行各种操作，唯独不能对其内容进行操作

public class FileDemo {
    public static void main(String[] args) {
    //创建一个file 对象 指向 一个文件或者目录 文件或者目录不一定存在
    File file  = new File("d:"+File.separator+"a.txt");//separator 是分割符的意思 // 
    if(!file.exists())
    {
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    System.out.println("文件绝对路径"+file.getAbsolutePath());
    long lastmodifile = file.lastModified();
    DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
    String lastdate = df.format(new Date(lastmodifile));
    System.out.println("最后修改的日期 "+lastdate);


    File file2 = new File("c://hellword ");
    if(!file2.exists())
    {
        file2.mkdir();//创建一个目录

    }

    }

}

**

第二章 字节流

**

首先是输入流 读取到文件内容 并且打印

public static void read(){
        File file = new File("d://ceshi.txt");// 首先先创建一个文件
        try {
            //创建一个字节输入流
            InputStream input = new FileInputStream(file);
            byte[] bytes = new byte[1024*1024];
            //因为是字节输入流 所以只能用字节的方式去读取数据
            // byte 数组 的大小就是没次读取的长度 这里我设置的比较大
//如果把里面的参数设置为1 的话 代表的意思是每次读取一个字节 这样读取中文会出问题
            int len = -1;
            StringBuffer buffer = new StringBuffer();//创建一个StringBuffer 来接收读取的数据
            while((len =input.read(bytes))!=-1)     //当读取的长度不等于-1 代表没有读取完的时候 继续读取
            {
                buffer.append(new String(bytes,0,len));


            }
            input.close();                          //养成一个用完流就关闭的好习惯
            System.out.println(buffer);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }

接下来是输出流 想文件写入内容

public static void write(){
        File file = new File("d://ceshi.txt");
        if(file.exists()==false)
        {

            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
        try {
            OutputStream out = new FileOutputStream(file);
            String xieshu ="输入写入的内容 ";
            //写入数据  因为这里面是字节流 所以 要把我写入的字符串转换成字节的形式去写入
            out.write(xieshu.getBytes());
            out.close();//释放资源

        }  catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

第三章 字符流

首先是字符输入流 reader

public static void read(){
        File file = new File("d://asdcd.txt");//和字节流一样 首先要构造一个文件
        try {
            Reader reader = new FileReader(file); //创建一个读取reader
            char[] c = new char[10];         //这里面传入的不是字节 是字符了
            int len = -1;
            StringBuffer buffer = new StringBuffer();
            //下面实现思路与字节流的读取一样
            while((len =reader.read(c))!=-1)  
            {
                buffer.append(new String(c,0,len));
            }
            reader.close();
            System.out.println(buffer);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

下面是字符输出流

public static void write(){
        File file = new File("d://asdcd.txt");
        try {
            Writer out = new FileWriter(file);
            String xieshu ="你好 ， world";
            //写入数据
            out.write(xieshu); //这里想对于这个字节输入流而言 直接向文件输出字符串即可
            out.close();//释放资源

        }  catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

**

第四章 缓冲流

**
计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。
为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。
为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

下面分别是加上缓冲流之后的字符输入输出流 、 字节输入输出流

/**
     * 字符输出流
     */
    public static void zifuout()
   {
        try {
            Writer writer = new FileWriter("D:\\ceshi.txt");
            BufferedWriter bufferwriter = new BufferedWriter(writer);
            bufferwriter.write("测试字符缓冲流");
            bufferwriter.close();
            writer.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
   }
    /**
     * 字符输入流
     */
    public static void zifuin()
    {
        String result;
        try {
            Reader reader = new FileReader("D:\\ceshi.txt");
            BufferedReader bufferedReader = new BufferedReader(reader);
            result = bufferedReader.readLine();
            bufferedReader.close();
            reader.close();
            System.out.println(result);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }



    /**
     * 用字节输出流
     */
    public static void bufferout()
    {
        try {
            OutputStream out = new FileOutputStream("D:\\a.txt");
            BufferedOutputStream bufferout = new BufferedOutputStream(out);
            bufferout.write("测试用字节缓冲流写入文件 ".getBytes());
            bufferout.close();
            out.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    /**
     * 用字节输入流
     */
    public static void bufferin()
    {
        try {
            InputStream in = new FileInputStream("D:\\a.txt");
            BufferedInputStream bufferin = new BufferedInputStream(in);
            int len= -1;
            byte[] bytes =new byte[1024*1024];
            StringBuffer  result  = new StringBuffer();
            while((len=bufferin.read(bytes))!=-1)
            {
                result.append(new String(bytes,0,len));
            }
            bufferin.close();
            in.close();
            System.out.println(result);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

通过上面的例子 我们还可以发现，当我们 无论是给字符 还是字节输入输出流套上一层缓冲流的时候，当我们用缓冲流对象进行读写的时候，会多一些方法！ 比如readline() 等一写常见好用的方法！所以 建议以后再写流的时候一定要套上缓冲流

第五章 其他常见的流

• 打印流

推荐一个很好用，很常用的输出流 — 打印流

/**
     * PrintStream  字节打引流
     */
    public static void shuchu(){
        try {
            OutputStream out = new FileOutputStream("D:\\a.txt");
            BufferedOutputStream bos = new BufferedOutputStream(out);
            //bos.write("写入的内容".getBytes());//原来的方法 
            PrintStream ps = new PrintStream(bos);
            ps.println("写入的内容");//用打印流之后的方法
            bos.close();
            ps.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    /**
     * 字符打印流 Print Writer
     */
    public static void shuchu2(){
        try {
            Writer writer = new FileWriter("D:\\a.txt");
            BufferedWriter bufferedWriter = new BufferedWriter(writer);
            PrintWriter printWriter = new PrintWriter(bufferedWriter);
            printWriter.print("写入的内容");
            printWriter.close();
            bufferedWriter.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }

• 数据流

    public static void DataOut(){
    try {
        OutputStream out = new FileOutputStream("d:\\a.txt");
        DataOutputStream dos = new DataOutputStream(out);
        dos.writeInt(10);//  按照数据 类型 去写
        dos.writeUTF("测试数据流 ");
        dos.close();
        out.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    }

    public static void DataIn(){
        try {
            InputStream in = new FileInputStream("d:\\a.txt");
            DataInputStream dis= new DataInputStream(in);
            int a =dis.readInt();    //按照数据类型去读
            String asd= dis.readUTF();
            dis.close();
            in.close();
            System.out.println(a+asd);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }

• 字符串流

public static void StringStream()
    {

        String s = "需要解析的文件";
        StringReader reader = new StringReader(s);
        //这样就 可以 用 流的方式去读取

    }

当我们从网上截取一段报文 一段文字 一段密文 需要用流的形式去解析的时候 字符串流是一个不二选择，不会抛出任何IO异常

• 字节数组流

/**
     * 在内存中操作
     */
    public static void bytearryStream(){

        String info = "字节数组流测试";
        ByteArrayInputStream  bis = new ByteArrayInputStream(info.getBytes());
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int i =-1;

        while((i=bis.read())!=-1)
        {
            bos.write(i);
        }
        //可以把一个图片的数据写进去 这个 ByteArray里面
        System.out.println(bos.toString());


    }

这个流的特点是在内容当中操作 与外部文件 无关，且不会产生IO异常

此文章为自己总结 ，欢迎大家改正批评！ 不喜勿喷