IO 字节流

野性酷女 2022-12-26 11:24 173阅读 0赞

### 文章目录 ###

*  字节流
 *   *   *  一、字节流写数据
         *   *   *  字节流写数据时的问题
                 *  字节流写数据加异常处理
         *  二、字节流读数据
         *  三、字节流练习
 *  字节缓冲流

--------------------

# 字节流 #

**字节流抽象基类**

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();
        }
    }

1.  复制图片
    
    需求：  
    把“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));
            }
        }