• Java—字节流

    目录

    1.字节流

    1.1 IO流概述和分类

    1.2字节流写数据

    1.3字节流写数据的3种方式

    1.4字节流写入数据的两个小问题

    1.5字节流写数据加异常处理

    1.6字节流读数据(一次读一个字节数据)

    1.7案例:复制文本文件

    1.8字节流复制图片

    1.9字节缓冲流

    1.字节流

    1.1 IO流概述和分类

    IO流概述:
            IO:输入/输出(Input/Output)
            流:是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输

            IO流就是用来处理设备间数据传输问题的
            常见的应用:文件复制;文件上传:文件下载


    IO流分类:
            按照数据的流向
                    输入流:读数据

                    输出流:写数据

            按照数据类型来分
                    字节流
                            字节输入流;字节输出流

                    字符流
                            字符输入流;字符输出流

    一般来说，我们说IO流的分类是按照数据类型来分的

    那么这两种流都在什么情况下使用呢?
            如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，
            否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

    1.2字节流写数据

    字节流抽象基类
            InputStream:这个抽象类是表示字节输入流的所有类的超类

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

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

    FileOutputStream:文件输出流用于将数据写入File
            FileOutputStream(Stringname):创建文件输出流以指定的名称写入文件

    使用字节输出流写数据的步骤:
            1.创建字节输出流对象

                    调用系统功能创建了文件

                    创建字节输出流对象

                    让字节输出流对象指向文件

            2.调用字节输出流对象的写数据方法
            3.释放资源(关闭此文件输出流并释放与此流相关联的仟何系统资源

    1. package zyy04;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. public class Demo {
    8.     public static void main(String[] args) throws IOException {
    9.         //创建字节输出流对象
    10.         FileOutputStream fos=new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\fos.txt");
    11.         /*
    12.         做了三件事情：
    13.             调用系统功能创建了文件；
    14.             创建了字节输出流对象；
    15.             让字节输出流对象指向创建好的文件
    16.         */
    17.         //write(int b):将指定的字节写入此文件输出流
    18.         fos.write(97);
    19.         fos.write(57);
    20.         fos.write(55);
    21.         //最后都要释放资源
    22.         //close（）：关闭此文件输出流并释放与此流相关联的任何系统资源
    23.         fos.close();
    24.     }
    25. }

    1.3字节流写数据的3种方式

    1. package zyy04;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) throws IOException {
    8.         //FileOutputStream():创建文件输出流以指定的名称写入文件
    9.         FileOutputStream fos= new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\fos.txt");
    10.         //write(int b):将指定的字节写入此文件输出流
    11.         fos.write(97);
    12.         fos.write(98);
    13.         fos.write(99);
    14.         fos.write(100);
    15.         //write(byte[] b):将b.length字节从指定的字节数组写入此文件输出流
    16.         byte[] bys={97,98,99,100,101};
    17.         fos.write(bys);
    18.         //write(byte[]b,int off,int len):将len字节从off开始写入此文件输出流
    19.         fos.write(bys,1,3);
    20.     }
    21. }

    1.4字节流写入数据的两个小问题

    1：字节流实现换行

            Windows：\r\n

            Linux:\n

            mac:\r

    2:字节流写数据如何实现追加写入

            FileOutputStream(String name,boolean append)

            创建文件输出流已制定的名称写入文件。如果第二个参数为true，则字节将写入文件的末尾而不是开头

    1. public class Demo {
    2.     public static void main(String[] args) throws IOException {
    3.         //FileOutputStream():创建文件输出流以指定的名称写入文件
    4.         FileOutputStream fos= new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\fos.txt",true);
    5.         //写数据
    6.         for(int i=0;i<10;i++){
    7.             fos.write("hello".getBytes());
    8.             fos.write("\r\n".getBytes());
    9.         }
    10.         //释放资源
    11.         fos.close();
    12.     }
    13. }

    1.5字节流写数据加异常处理

    finally:在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源
     

    特点:被finally控制的语句一定会执行，除非JVM退出

    1. package zyy04;
    2.  
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5.  
    6. public class Demo {
    7.     public static void main(String[] args) {
    8.         //FileOutputStream():创建文件输出流以指定的名称写入文件
    9.         FileOutputStream fos=null;
    10.         try {
    11.             fos= new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\fos.txt",true);
    12.             fos.write("hello".getBytes());
    13.         } catch (IOException e) {
    14.             e.printStackTrace();
    15.         }finally {//加入finally来实现释放资源
    16.             if(fos!=null) {//判断保持更健壮
    17.                 try {
    18.                     fos.close();
    19.                 } catch (IOException e) {
    20.                     e.printStackTrace();
    21.                 }
    22.             }
    23.         }
    24.  
    25.     }
    26. }

    1.6字节流读数据(一次读一个字节数据)

    需求:把文件fos.txt中的内容读取出来在控制台输出

    FilelnputStream:从文件系统中的文件获取输入字节
            FilelnputStream(Stringname):通过打开与实际文件的连接来创建一个FilelnputStream

            该文件由文件系统中的路径名name命名

    使用字节输入流读数据的步骤:
            创建字节输入流对象
            调用字节输入流对象的读数据方法

            释放资源

    1. package zyy04;
    2.  
    3.  
    4. import java.io.FileInputStream;
    5. import java.io.IOException;
    6.  
    7. public class Demo {
    8.     public static void main(String[] args) throws IOException {
    9.         //创建字节输入流对象
    10.         //FileInputStream()
    11.         FileInputStream fis=new FileInputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\fos.txt");
    12.         //调用字节输入流对象的读数据方法
    13.         //read()
    14.         int by=fis.read();
    15.         System.out.println(by);
    16.         System.out.println((char)by);
    17.         //如果达到文件的末尾，-1
    18.         //循环读取
    19.         int by1=fis.read();
    20.         while(by1!=-1){
    21.             System.out.println(by);
    22.             System.out.println((char)by);
    23.             by1=fis.read();
    24.         }
    25.         //优化循环
    26.         int by2;
    27.         while((by2=fis.read())!=-1){
    28.             System.out.println(by);
    29.             System.out.println((char)by);
    30.         }
    31.         //释放资源
    32.         fis.close();
    33.     }
    34. }

    1.7案例:复制文本文件

    需求:把“E:\\山海经.txt”复制到模块目录下的“山海经.txt”

    分析:
    ①复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
    ②数据源:
    E:\\山海经.txt---读数据---InputStream---FilelnputStream

    ③目的地: 

    practise\\山海经.txt---写数据---OutputStream---FileOutputStream

    思路:
    根据数据源创建字节输入流对象

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

    1. package zyy04;
    2.  
    3.  
    4. import java.io.FileInputStream;
    5. import java.io.FileOutputStream;
    6. import java.io.IOException;
    7.  
    8. public class Demo {
    9.     public static void main(String[] args) throws IOException {
    10.         //根据数据源创建字节输入流对象
    11.         FileInputStream fis=new FileInputStream("E:\\山海经.txt");
    12.         //根据目的地创建字节输出流对象
    13.         FileOutputStream fos=new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\山海经.txt");
    14.         //读写数据，复制文本文件
    15.         int by;
    16.         while((by=fis.read())!=-1){
    17.             fos.write(by);
    18.         }
    19.         //释放资源
    20.         fis.close();
    21.     }
    22. }

    1.8字节流复制图片

    案例:复制图片

    需求:把“E:\\dd.jpg”复制到模块目录下的“dd.jpg"

    思路:
    根据数据源创建字节输入流对象
    根据目的地创建字节输出流对象
    读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)释放资源

    1. package zyy04;
    2.  
    3.  
    4. import java.io.FileInputStream;
    5. import java.io.FileOutputStream;
    6. import java.io.IOException;
    7.  
    8. public class Demo {
    9.     public static void main(String[] args) throws IOException {
    10.         //根据数据源创建字节输入流对象
    11.         FileInputStream fis=new FileInputStream("E:\\dd.jpg");
    12.         //根据目的地创建字节输出流对象
    13.         FileOutputStream fos=new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\dd.jpg");
    14.         //读写数据，复制图片
    15.         byte[] bys=new byte[1024];
    16.         int len;
    17.         while((len=fis.read())!=-1){
    18.             fos.write(bys,0,len);
    19.         }
    20.         //释放资源
    21.         fis.close();
    22.         fos.close();
    23.     }
    24. }

    1.9字节缓冲流

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

    构造方法:
    字节缓冲输出流:BufferedOutputStream(OutputStreamout)

    字节缓冲输入流:BufferedInputStream(InputStreamin)

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

    1. package zyy04;
    2.  
    3. import java.io.*;
    4.  
    5. public class Demo {
    6.     public static void main(String[] args) throws IOException {
    7.         //字节缓冲输出流
    8.         BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\bos.txt"));
    9.         //写数据
    10.         bos.write("hello\r\n".getBytes());
    11.         bos.write("world\r\n".getBytes());
    12.         //字节缓冲输入流
    13.         BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\IdeaProject\\JavaSE_Code\\practise\\bos.txt"));
    14.         //一次读一个字节数组数据
    15.         byte[] bys=new byte[1024];
    16.         int len;
    17.         while((len=bis.read())!=-1){
    18.             System.out.println(new String(bys,0,len));
    19.         }
    20.         //释放资源
    21.         bis.close();
    22.         bos.close();
    23.     }
    24. }

  • 相关阅读:
    亚马逊平台的优势有哪些？
    恢复二叉树思路及代码
    vue 设置定时器在某个时间段执行
    统计套利—配对交易策略
    完美解决新旧R版本冲突ggplot包不能安装问题
    小程序压缩
    题解 【LGR-087】洛谷 7 月月赛 Div.2
    串联起深度学习的整体，以及其他领域
    组件框架网站+demo库+svg库+渐变色库网站+矢量图网站等等
    红警快捷键总结
  • 原文地址：https://blog.csdn.net/qq_62799214/article/details/126325795