IO 字节流

---

字节流

字节流抽象基类

lnputStream：这个抽象类是表示字节输入流的所有类的超类

OutputStream：这个抽象类是表示字节输出流的所有类的超类

子类名特点:子类名称都是以其父类名作为子类名的后缀

 

一、字节流写数据

FileOutputStream:文件输出流用于将数据写入File（OutputStream抽象类的子类）

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

/*
    FileOutputStream：文件输出流用于将数据写入File
        FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
 */
public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        创建字节输出流对象
        做了三件事情
            A:调用系统功能创建了文件
            B:创建了字节输出流对象
            C:让字节输出流对象指向创建好的文件
         */
        FileOutputStream fs = new FileOutputStream("fs.txt");
        
        //void write(int b):将指定的字节写入此文件输出流
        fs.write("Hello".getBytes());
        
        //void close():关闭此输入流并释放与流相关联的任何系统资源。
        fs.close();
    }
}

写数据的三种方法

• void write(byte[] b)：将 b.length个字节从指定的字节数组写入此文件输出流。 一次写一个字节数组的数据

• void write(byte[] b, int off, int len)：将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
  一次写一个字节数组的部分数据

• void write(int b)：将指定的字节写入此文件输出流。
  一次写一个字节的数据

 

字节流写数据时的问题

1. 字节流写数据如何实现换行

   windows:\r\n
   linux:\n
   mac:\r

2. 字节流写数据如何实现追加写入(第二次运行时添加在后面)

   FileOutputStream(File file, boolean append)：创建文件输出流以写入由指定的 File对象表示的文件。
   如果第二个参数是true ，则字节将被写入文件的末尾而不是开头

public class FileOutputStreamDemo3 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("fos.txt",true);	//实现追加写入

        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());   //实现换行
        }
        fos.close();
    }
}

 

字节流写数据加异常处理

public class FileOutputStreamDemo4 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("fos.txt",true);
            fos.write("hello".getBytes());
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if (fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

 

二、字节流读数据

FileInputStream:文件输入流用于从文件系统中的文件获取输入字节。（InputStream抽象类的子类）

FileInputStream(String name) ：通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name 命名。

/*
    需求：把文件中的内容读取出来在控制台输出

    使用字节输入流读取数据步骤
        1：创建字节输入流对象
        2：调用字节输入流对象的读数据方法
        3：释放资源
 */
public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("fos.txt");
        
    /*
        //int read (byte[] b):从该输入流读取最多b.length个字节的数据到一个字节数组
        int len = fis.read(b);  //实际读取到的字节的长度，读取到末尾的话就会返回-1
    */
        
        //一次读一个字节
        int bys;
        while((bys=fis.read())!=-1){
            System.out.println(bys);
        }

        //一次读取一个字符数组
        byte[] bytes = new byte[1024];
        int lens;
        while((lens=fis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,lens));
        }
        //释放资源
        fis.close();
    }
}

读取数据的方法：

• read(): 一次读取一个字节的内容，存储到返回值中，返回值类型int类型，每次读取一个字节的内容，指向的位置就会向后偏移一个字节，如果读取到文件末尾，会返回-1，如果获取到-1说明读取结束了
• read(byte[] b):一次读取多个字节，把字节信息存储到数组中，返回值代表向b数组中存储的字节个数，如果返回值为-1，说明读取文件结束了

注：

• read() 返回值是内容
• read(byte[] b) 返回值是存储内容的长度

 

三、字节流练习

1. 复制文本文件

   需求：
   把 E:\Java\1212.txt 复制到模块目录下的“1212.txt”
   数据源:
   E:\Java\1212.txt —读数据— InputStream — FiLeInputStream
   目的地:
   IO流\1212.txt —写数据— OutputStream — FileOutputStream

   思路:
   1:根据数据源创建字节输八流对象
   2:根据目的地创建字节输出流对象
   3:读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
   4:释放资源

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("E:\\Java\\1212.txt");
        FileOutputStream fos = new FileOutputStream("12.txt");

        //一次读取一个字节
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }

        /*//一次读一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }*/
        fos.close();
        fis.close();
    }
}

2. 复制图片

   需求：
   把“E:\picture\java.jpg”复制到模块目录下的“java1.jpg”

   思路:
   1 :根据数据源创建字节输八流对象
   2:根据目的地创建字节输出流对象
   3:读写数据，复制文本文件(一次读取一个字节数组，一次写入一个字节数组)
   4:释放资源

   public class CopyJpgDemo {
       public static void main(String[] args) throws IOException{
           FileInputStream fis = new FileInputStream("E:\\picture\\java.jpg");
           FileOutputStream fos = new FileOutputStream("java2.jpg");
           byte[] bytes = new byte[1024];
           int len;
           while((len=fis.read(bytes))!=-1){
               fos.write(bytes,0,len);
           }
           fis.close();
           fos.close();
       }
   }
   

 
 

字节缓冲流

字节缓冲流:
BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
BufferedlnputStream:创建BufferedInputstream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法:
字节缓冲输出流: BufferedOutputStream(OutputStream out)字节缓冲输入流: BufferedInputStream(InputStream in)
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?
字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

/*
    字节缓冲流:
        BufferOutputStream
        BufferedInputStream
    构造方法:
        字节缓冲输出流: BufferedOutputStream (OutputStream out)
        字节缓冲输入流:BufferedInputStream (inputStream in)

 */
public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        字节缓冲输出流: BufferedOutputStream (OutputStream out)
        //FileOutputStream fos = new FileOutputStream("12.txt");
        //BufferedOutputStream bos = new BufferedOutputStream(fos);

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("12.txt"));
        //写数据
        bos.write("hello buffered".getBytes());
        bos.write("haha".getBytes());
        bos.close();
        */

        //字节缓冲输入流:BufferedInputStream (inputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("12.txt"));
        /*//一次读取一个字节
        int bys;
        while((bys=bis.read())!=-1){
            System.out.print((char) bys);
        }*/

        //一次读取一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len=bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
    }