Java|IO流之字节流

Java|IO流之字节流

字节流：FileInputStream、FileOutputStream；
字节缓冲流：BufferedInputStream、BufferedOutputStream

1. IO流概述及其分类
2. FileInputStream
3. FileOutputStream
4. 示例：复制文本文件
5. 示例：流的异常处理
6. 字节缓冲流：BufferedInputStream与BufferedOutputStream

1.IO流概述及其分类

IO流概述

• :IO流用来处理设备之间的数据传输,
• Java对数据的操作是通过流的方式
• Java用于操作流的对象都在IO包中

IO流分类:

• 按照数据流向
  –输入流:读入数据
  –输出流:写出数据
• 按照数据类型
  –字节流 可以读写任何类型的文件 比如音频 视频 文本文件
  ex:InputStream ，OutputStream
  – 字符流 只能读写文本文件
  ex:Reader ， Writer
  
  流的类型的选择:如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流，否则用字节流。

2. FileInputStream

构造方法
1.FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
2.FileInputStream(String name)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

 		//FileIntputStream(输出流)所关联的文件，如果该文件不存在 ，系统会报错
        FileInputStream in1 = new FileInputStream(new File("b.txt"));
        FileInputStream in2 = new FileInputStream("a.txt");

成员方法：
1. int read()
从此输入流中读取一个数据字节。()
2.int read(byte[] b)
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
3.int read(byte[] b, int off, int len)
从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

		//1.int read()
        int read = in1.read();   //返回字符的ASCII码值
        System.out.println(read);
        read = in1.read();      //指针向后移动，接着上面读数据
        System.out.println(read);
        read = in1.read();
        System.out.println(read);

        System.out.println("**********");
        //2.int read(byte[] b)  //返回读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。

        byte[] bytes = new byte[1024];
        int len1 = in1.read(bytes);    //读到的内容放到bytes数组中，返回读入的字节数
        String s = new String(bytes);  //类型转换：byte[] ===> String
        System.out.println(s);
        System.out.println(len1);


        //3.int read(byte[] b, int off, int len)
        int len2 = in2.read(bytes);
        System.out.println(len2);

3. FileOutputStream

构造方法
1.FileOutputStream(File file)
2.FileOutputStream(String name)

追加输入流：
3.FileOutputStream(File file, boolean append)
4.FileOutputStream(String name, boolean append)
第二个参数：true 代表追加写入，false 不追加

		File file = new File("a.txt");
        //FileOutputStream(输入流)所关联的文件，如果该文件不存在 ，系统会自动创建
        FileOutputStream fileOutputStream = new FileOutputStream(file);//java.io包下，不要导错包

        FileOutputStream fileOutputStream1 = new FileOutputStream("b.txt");

        //流用完后,必须释放资源
        fileOutputStream.close();
        fileOutputStream1.close();

成员方法
1.public void write(int b):写一个字节 超过一个字节 砍掉前面的字节
2.public void write(byte[] b):写一个字节数组
3.public void write(byte[] b,int off,int len):写一个字节数组的一部分

		//1.public void write(int b)
        FileOutputStream out = new FileOutputStream(new File("a.txt"));
        out.write(97);  //参数是字符的ASCII码值，写入文本后显示的是字符

        //2.public void write(byte[] b)
        byte[] bytes = {97,98,99};
        out.write(bytes);

        //3.public void write(byte[] b,int off,int len)
        out.write(bytes,0,2);


        //写入一串字符到文件中               转换:String---->bytes
        String s="感谢你如此精彩耀眼";
        byte[] bytes1 = s.getBytes();
        out.write(bytes1);

        //在文件中写入换行符
        //各平台的换行符：
        //windows下的换行符只用是 \r\n
        //Linux		\n
        //Mac		\r
        //eclipse/IDEA 中的记事本软件以及editplus这样的第三种软件都做了平台的兼容

        out.write("\r\n".getBytes());
        out.write("做我平淡岁月里星辰".getBytes());

        out.close();

注意事项

• 1.数据的换行
  a:windows： \r\n
  b:Linux： \n
  c:Mac： \r
  eclipse/IDEA 中的记事本软件以及editplus这样的第三种软件都做了平台的兼容

• 2.创建字节输出流对象了做了几件事情?
  a:调用系统资源创建a.txt文件
  b:创建了一个fos对象
  c:把fos对象指向这个文件

• 3.为什么一定要close()?
  a: 通知系统释放关于管理a.txt文件的资源
  b: 让Io流对象变成垃圾,等待垃圾回收器对其回收

4. 示例：复制文本文件

• 方式1：字节流一次读入一个字节
  速度慢，不推荐
• 方式2：定义一个字节数组充当缓冲区
  速度快，推荐

		FileInputStream in = new FileInputStream("a.txt");
        FileOutputStream out = new FileOutputStream("aCopy.txt");

        byte[] bytes = new byte[1024 * 8];
        int len=0;

        while ((len=in.read(bytes))!=-1){
            out.write(bytes,0,len);
            out.flush();
        }
        in.close();
        out.close();

5. 示例：流的异常处理

        //流的异常处理
        FileInputStream in=null;
        FileOutputStream out=null;

        try{
            in = new FileInputStream("a.txt");
            out = new FileOutputStream("aa.txt");
            byte[] bytes = new byte[1024 * 1024];
            int len = 0;//记录每次读取到的有效字节个数
            while ((len = in.read(bytes)) != -1) {
                out.write(bytes, 0, len);
                out.flush();
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //释放资源
            try {
                if (in != null) {
                    //快捷键 in.nn  (in not null)
                    in.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

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

        }

6. 字节缓冲流

字节缓冲流（高效字节输入输出流）的引入：
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果， java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流（高效字节输入输出流）：BufferedInputStream 和 BufferedOutputStream

BufferedInputStream
构造方法：

• 1.BufferedInputStream(InputStream in)
  创建一个 BufferedInputStream 并保存其参数

• 2.BufferedInputStream(InputStream in, int size)
  创建具有指定缓冲区大小的 BufferedInputStream

BufferedOutputStream
构造方法：

• 1.BufferedOutputStream(OutputStream out)
  创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
• 2.BufferedOutputStream(OutputStream out, int size)
  创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

        BufferedInputStream bin = new BufferedInputStream(new FileInputStream("a.txt"));
        BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("aaa.txt"));

        byte[] bytes = new byte[1024];
        int len=0;
        while ((len=bin.read(bytes))!=-1){
            bout.write(bytes);
            bout.flush();
        }

        bin.close();
        bout.close();

快捷键：ctrl+H 可以看一个类继承的继承关系