java大法之IO流（上）

nsyuk

已于 2022-04-15 09:41:01 修改

阅读量705

点赞数 12

分类专栏： java基础知识文章标签： java

于 2022-04-15 09:19:54 首次发布

本文链接：https://blog.csdn.net/yiuiukk/article/details/124118509

版权

java基础知识专栏收录该内容

4 篇文章 1 订阅

订阅专栏

7.字节流读数据（一次读一个字节数组数据）

8.字节缓冲流

[前言]

大家好，我是你们的躺平哥，希望和大家一起努力进入理想的公司！冲冲冲！！一起学习的小伙伴们可以点赞支持一下，大家一起加油，嘿嘿~

***在系统学习之前为了理解一下IO流是干啥的，我特意去搜了一下，感觉他说的很容易理解，如下：

Java中的IO流是输入输出流。至于理解，可以将输入和输出两个端点看作是两个工厂，工厂之间需要互相运输货物，而流则是两工厂之间的公路，没有公路就不能互相运输，至于字符，字节和二进制则可以看作是运输的方式和单位大小，比如说把二进制理解成三轮车，那么字节就是小卡车，而字符则是集卡之类的。

1.IO流的概述和分类

IO流概述：

IO：输入/输出（input/output）

流：是一种抽象概念，是对数据传输的总称。也就是说在设备间的传输称为流。流的本质是数据传输！

IO流就是用来处理设备间数据传输问题的

常见的应用：文件复制；文件上传；文件下载

IO流分类：

1）按照数据的流向

输入流：读数据

输出流：写数据

2）按照数据类型来分

字节流

字节输入流；字节输出流

字符流

字符输入流；字符输出流

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

那么问题来了，什么时候用字节流什么时候用字符流？

如果数据通过window自带的笔记本软件打开，我们还可以读懂里面的内容，使用字符流，否则就用字节流。如果你不知道该使用哪种类型的流，就用字节流（万能）。

2.用字节流写数据

字节流抽象基类：

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

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

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

FileOutputStream:文件输出流用于将数据写入File

FileOutputStream(String name):创建文件输出流以指定的名称写入文件【构造方法】

package com.itheima_01;
import java.io.FileNotFoundException;

import java.io.FileOutputStream;
import java.io.IOException;
/*
FileOutputStream:文件输出流用于将数据写入File
FileOutputStream(String name);创建文件输出流以指定的名称写入文件


 */
public class demo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutStream(String name );创建文件输出流以指定的名称写入文件

        FileOutputStream fos =new FileOutputStream("fos.txt");
/*
坐了三件事情：
A：调用系统创建功能创建了文件
B:创建了字节输出流对象
C:让字节输出流对象指向创建好的文件
 */
//void write (int b;)将指定的字节写入此文件输出流
fos.write(97);
//fos.write(57);
//fos.write(55);字符9跟7！
//最后都要释放资源
//void close();关闭此文件输出流并释放与此相关联的任何系统资源。
fos.close();

    }
}

总结：使用字节输出流写数据的步骤：

1）创建字节输出（调用系统功能创建了文件，创建字节输出流对象，让字节输出流向对象）

2）调用字节输出流对象的写数据方法。

3）释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）

3.字节流写数据的三种方式

注：int off是索引开始，即从int off开始写长度为int len 的数据到文件输出流

构造方法和输出方法的代码演示如下（手动敲得！）：

package itheima;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
    class demo1 {
        public static void main(String[] args) throws IOException {
            FileOutputStream fos = new FileOutputStream("fos.txt");
//new File(name)
//FileOutputStream fos=new FileOutputStream(new File("myByteStream\\fos.txt"))
//FileOutputStream(File file);创建文件按输出流以指定的File对象表示的文件
/*File file=new File("fos.txt")
FileOutputStream fos2 =new FileOutStream(file);
FileOutputStream fos2 =new FileOutStream(new File("fos.txt"));
以上就是两种构造方法，一般使用第一种就行
void write(int b);将指定的字节输入此文件输出流
 */
      //      fos.write(97);
//            fos.write(98);
 //           fos.write(99);
  //          fos.write(100);
 //           fos.write(101);
//    void write(byte[] b);将b.length字节从指定的字节数组写入此文件输出流
    //        byte[] bys ={97,98,99,100,101};
//byte[] getBytes();返回字符串对应的字节数组
            byte[] bys = "abcde".getBytes();
         //   fos.write(bys);
//void write(byte[] b,int off,int len);将len字符从指定的字节数组开始，从偏移量off开始写入此文件输出流
//fos.write(bys,0,bys.length);
 fos.write(bys,1,3);
 //释放资源
            fos.close();
        }
    }

4.字节流写数据的两个小问题

字节流写数据的两个小问题：
1：字节流写数据如何实现换行呢？
2：字节流写数据如何实现追加写入呢？

1）如何实现换行

package itheima;

import java.io.FileOutputStream;
import java.io.IOException;


public class demo2 {
    /*
    字节流写数据的两个小问题：
    1：字节流写数据如何实现换行呢？
    2：字节流写数据如何实现追加写入呢？

     */
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos2 = new FileOutputStream("fos2.txt");
        //写数据
        for (int i = 0; i < 10; i++) {
            fos2.write("hello".getBytes());
            fos2.write("\n".getBytes());

        }
//释放资源
        fos2.close();

    }
}

2）写数据如何实现追加写入？

换一个构造方法即可！

public FileOutputStream(String name,boolean append)

具体实例如下：

package itheima;

import java.io.FileOutputStream;
import java.io.IOException;


public class demo2 {
    /*
    字节流写数据的两个小问题：
    1：字节流写数据如何实现换行呢？
    window:\r\n
    2：字节流写数据如何实现追加写入呢？
public FileOutputStream(String name,boolean append)
创建文件输出流已指定的名称写入文件。
如果第二个参数为ture，则字节将写入文件的末尾而不是开头


     */
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
       // FileOutputStream fos2 = new FileOutputStream("fos2.txt");
        FileOutputStream fos2 = new FileOutputStream("fos2.txt",true);
        //写数据
        for (int i = 0; i < 10; i++) {
            fos2.write("hello".getBytes());
            fos2.write("\n".getBytes());

        }
//释放资源
        fos2.close();

    }
}

5.字节流写数据加异常处理

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

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

try{
肯呢个出现的异常代码：
}catch（异常类名 变量名）
异常的处理代码：
}finally{
执行所有清除的操作；
}

package itheima;

import javax.imageio.IIOException;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class demo3 {
    /*
    字节流写数据加入异常处理
     */
    public static void main(String[] args) {
//        try{
// FileOutputStream fos3=new FileOutputStream("fos3.txt");
//fos3.write("hello".getBytes());
//fos3.close();
//        }catch(IOException e){
//            e.printStackTrace();
//        }
        //加入finally来实现释放资源
        FileOutputStream fos3 = null;
        try {
            fos3 = new FileOutputStream("fos3.txt");
            fos3.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos3 != null) //在释放资源之前要进行不为null的判断
            {
                try {
                    fos3.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

6.字节流读数据（一次读一个字节数据）

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

FileInputStream:把文件系统中的文件获取输入字节

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

使用字节输入流读数据的步骤：

（1）创建字节输入流对象

（2）调用字节输入刘对象的读数据方法

（3）释放资源

package cn.itcast.demo;
import java.io.FileInputStream;
import java.io.IOException;

public class demo1 {
    public static void main(String[] args)throws IOException {
        FileInputStream fis=new FileInputStream("C:\\ECLIPSE\\fos.txt");
      //第一次读取
int by= fis.read();
        System.out.println(by);
        System.out.println((char)by);
        //第二次读取数据
        by =fis.read();
        System.out.println(by);
        System.out.println((char)by);
        //再多读取两次
by =fis.read();
System.out.println(by);
by =fis.read();
System.out.println(by);
int by =fis.read();
while(by !=-1){
System.out.print(（char）by);
by=fis.read();

}
//优化上面的程序
/*
fis.read();读数据
by=fis.read();把读到的·数据赋值给by
by!=-1;判断读取到的数据是否是-1

*/

int by;
while((by=fis.read())!=-1){
System.out.print(（char）by);
}







//释放资源
        fis.close();
    }

}

如果文件读到末尾，读取的为-1；

字节流读数据的标准代码

int by;
while((by=fis.read())!=-1){
System.out.print(（char）by);
}

案例：复制文本文件

需求：把“C\\itcast\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”

思路：

1.根据数据源创建字节输入流对象。

2.根据目的地创建字节流输出对象

3.读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）

4释放资源

package cn.itcast.demo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class demo2 {
    public static void main(String[] args)throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis=new FileInputStream("C:\\itcast\\窗里窗外.txt");
    //根据目的地创建字节输出流对象
FileOutputStream fos=new FileOutputStream("C:\\itcast\\窗里窗外.txt");
//读取数据，复制文本（一次读取一个字节，一次写入一个字节）
int by;
while((by=fis.read())!=-1) {
    fos.write(by);
}
//释放资源
        fos.close();
        fis.close();


    }

}

7.字节流读数据（一次读一个字节数组数据）

    import java.io.FileInputStream;
import java.io.IOException;

    public class demo01 {
        /*
    需求：把文件fos.txt中的内容读取出来在控制台输出
    使用  字节输入流读数据的步骤
    1.创建字节输入流对象
    2.调用字节输出流对象的读数据方法
    3.释放资源
     */
        public static void main(String[] args) throws IOException {
            //创建字节输入流对象
            FileInputStream fis=new FileInputStream("D:\\Java\\src\\fos.txt");
            /*
调用字节输入流对象得读数据方法
int read(byte[] b);从该输入流读取最多b.length个字节的数据到一个字节数组
*/
 /*           byte[] bys=new byte[5];
//第一次读取数据
            int len =fis.read(bys);
            System.out.println(len);
            //String (byte[] bytes)
            System.out.println(new String(bys));
            System.out.println(new String(bys,0,len));
//第二次读取数据
            int len =fis.read(bys);
            System.out.println(len);
            //String (byte[] bytes)
            System.out.println(new String(bys));
            System.out.println(new String(bys,0,len));
//第三次读取数据
            int len =fis.read(bys);
            System.out.println(len);
            //String (byte[] bytes)
            System.out.println(new String(bys));
            System.out.println(new String(bys,0,len));
*/
//优化方案
byte[] bys =new byte[1024];//1024及其整数倍
int len;
while((len=fis.read(bys))!=-1){
    System.out.println(new String(bys,0,len));
}

/*
hello\r\n
world\r\n
第一次：hello
第二次：\r\nwor
第三次：ld\r\nr
 */
            //释放资源
            fis.close();


        }

    }

优化方案：

byte[] bys =new byte[1024];//1024及其整数倍
int len;
while((len=fis.read(bys))!=-1){
    System.out.println(new String(bys,0,len));
}

案例：复制图片

需求：把E：\\itcast\\mn.jpg复制到模块目录下的mn.jpg

思路：

1：根据数据源创建字节输入流对象

2：根据目的地创建字节输出流对象

3：读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）

4：释放资源

代码如下：

package cn.itcast;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class defmo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("C:\\itcast\\mn.jpg");
        FileOutputStream fos=new FileOutputStream("D:\\Java\\untitled\\mn.jpg");
byte[]bys =new byte[1024];
int len;
while((len=fis.read(bys))!=-1){
    fos.write(bys,0,len);

}
fis.close();
fos.close();


    }
}

8.字节缓冲流

字节缓冲流：

作用：提高读写数据效率的

*BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

BufferredInputStream:创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节。

构造方法：

字节缓冲输出流： BufferedOutputStream(OutputStream out)

字节缓冲输入流： BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

字节缓冲流仅仅提供缓冲区，而真正读写数据还得依靠基本的字节流对象进行操作

字节缓冲流读数据和写数据代码如下：

import java.io.*;

public class demo {
    //字节缓冲输出流：BufferedOutputStream(OutputStream out)
//字节缓冲输入流： BufferedInputStream(InputStream in)
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流： BufferedOutputStream(OutputStream out)
//    FileOutputStream fos=new FileOutputStream("bos.txt" );
//    BufferedOutputStream bos=new BufferedOutputStream(fos);

  /*      BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("bos.txt" ));
//写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
//释放资源
        bos.close();

*/
        BufferedInputStream  bis=new BufferedInputStream(new FileInputStream("bos.txt" ));
//一次读取一个字节数据
//        int by;
//        while((by=bis.read())!=-1){
//            System.out.print((char)by);
//        }
    //一次读取一个字节数组数据
       byte[] bys=new byte[1024];
       int len;
       while((len=bis.read(bys))!=-1){
           System.out.println(new String(bys,0,len));


       }


//释放资源
bis.close();

    }
}

案例：复制视频

需求：

把c\\itcast\\字节流复制图片.avi 复制到模块目录下的字节流复制图片.avi

思路：

1），根据数据源创建字节输入流对象

2），根据目的地创建字节输出流对象

3），读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）

4），释放资源

四种方式实现复制视频，并记录每种方式复制视频的时间

1）：基本字节流一次读写一个字节

2）：基本字节流一次读写一个字节数组

3）：字节缓冲流一次读写一个字节

4）：字节缓冲流一次读写一个字节数组

代码如下：

import java.io.*;
//四种方式实现复制视频，并记录每种方式复制视频的时间
//
//        1）：基本字节流一次读写一个字节 共耗时 64565毫秒
//
//        2）：基本字节流一次读写一个字节数组  共耗时 107   毫秒
//
//        3）：字节缓冲流一次读写一个字节   共耗时  405  毫秒
//
//        4）：字节缓冲流一次读写一个字节数组   共耗时  60 毫秒
public class demo {
    public static void main(String[] args) throws IOException{
        //记录开始时间
        long starTime =System.currentTimeMillis();
        //复制视频

        //method1();
//        method1();
//        method1();
//        method1();
        //记录结束时间
        long endTime =System.currentTimeMillis();
        System.out.println("共耗时："+(endTime-starTime));
   //基本字节流一次读写一个字节数组
   public static void   method2()  throws IOException {
       //E:\\itcast\\字节流复制图片.avi
        //模块目录下的 字节流 复制图片.avi
            FileInputStream fis=new FileInputStream("mg.mp4");
            FileOutputStream fos=new FileOutputStream("D:\\Java\\untitled2\\mg.mp4");
byte[] bys=new byte[1024];
int len;
while ((len= fis.read(bys))!=-1){
    fos.write(bys,0,len);
}
//基本字节流一次读写一个字节
            public static void   method2()  throws IOException {
            int by;
            while((by=fis.read())!=-1) {
                fos.write(by);
            }
               //字节缓冲流一次读写一个字节
                public static void   method3()  throws IOException {
                    BufferedInputStream bis=new BufferedInputStream("mg.mp4");
BufferedOutputStream bos =new BufferedOutputStream("D:\\Java\\untitled2\\mg.mp4");
int by;
while((by= bis.read())!=-1){
    bos.write(by);
}
//字节缓冲流一次读写一个字节数组
                    public static void   method4()  throws IOException {
                        BufferedInputStream bis=new BufferedInputStream("mg.mp4");
                        BufferedOutputStream bos =new BufferedOutputStream();
 byte[] bys=new byte[1024];
 int len;
 while((len=fis.read(bys)!=-1)){
     fos.write(bys,0,len);
     }

bos.close();
bis.close();

            }
}

根据以上不难看出，他们之间确实存在效率的差别的！

1）：基本字节流一次读写一个字节共耗时 64565毫秒

2）：基本字节流一次读写一个字节数组共耗时 107 毫秒

3）：字节缓冲流一次读写一个字节共耗时 405 毫秒

4）：字节缓冲流一次读写一个字节数组共耗时 60 毫秒

感谢未来大佬们的支持，冲冲冲！

nsyuk

关注

12
点赞
踩
8

收藏

觉得还不错? 一键收藏
21
评论
java大法之IO流（上）

[前言]***在系统学习之前为了理解一下IO流是干啥的，我特意去搜了一下，感觉他说的很容易理解，如下：Java中的IO流是输入输出流。至于理解，可以将输入和输出两个端点看作是两个工厂，工厂之间需要互相运输货物，而流则是两工厂之间的公路，没有公路就不能互相运输，至于字符，字节和二进制则可以看作是运输的方式和单位大小，比如说把二进制理解成三轮车，那么字节就是小卡车，而字符则是集卡之类的。1.IO流的概述和分类IO流概述：IO：输入/输出（input/output）流：...
复制链接

扫一扫

专栏目录