java第二十五天：IO流——字节流_out.write(bytes, 0, len);是什么意思-CSDN博客

本文链接：https://blog.csdn.net/weixin_46682579/article/details/106411096

java第二十五天：IO流——字节流

1_IO流概述及其分类(掌握)

A:IO流概述
	IO流用来处理设备之间的数据传输
	Java对数据的操作是通过流的方式
	Java用于操作流的对象都在IO包中 java.io
B:IO流分类
	a:按照数据流向 站在内存角度
		输入流	读入数据
		输出流	写出数据
	b:按照数据类型
		字节流 可以读写任何类型的文件 比如音频 视频  文本文件
		字符流 只能读写文本文件
		什么情况下使用哪种流呢?
		如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
		如果你什么都不知道，就用字节流

2_IO流基类概述和FileOutputStream

2.1_IO流基类概述

a:字节流的抽象基类：

InputStream ，OutputStream。

b:字符流的抽象基类：

Reader ， Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

2.2_FileOutputStream的构造方法(掌握)

由一个案例引出使用IO流写数据，由于字节流先出现就先学习字节输出流基类OutputStream，
使用具体子类FileOutputStream

public static void main(String[] args) throws IOException {
    //FileOutputStream ：文件输出流 是用于将数据写入 File
    //按住ctrl 点击添加书签
  /*  FileOutputStream(File file)
    创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

    FileOutputStream(String name)
    创建一个向具有指定名称的文件中写入数据的输出文件流。*/

    File file = new File("a.txt");
     //file.createNewFile();
    //创建一个文件输出流，来关联一个文件 当关联的文件不存在时，会自动帮你创建这个文件
    FileOutputStream out = new FileOutputStream(file);

    //往文件中写入数据
    System.out.println("============================");
    
    //直接传入文件的字符串路径也可以，如果输出流所关联的文件不存在，会自动创建
    FileOutputStream fileOutputStream = new FileOutputStream("b.txt");
    fileOutputStream.close();
}

2.3_Io流的分类:

(1): 按照流向进行划分

输入流输出流
(2): 按照操作的数据类型进行划分
字节流
字节输入流 InputStream 读
字节输出流 OutputStream 写
字符流
字符输入流 Reader 读
字符输出流 Writer 写

 需求:	往一个文本文件中写一串数据 Hello,IO

分析:
a:我们现在操作的是文本文件,所有按照我们的想法,我们优先现在字符流,但是字节流是优先于字符流.所以先使用字节流
b:因为我们要写数据,所以我们应该使用字节流中输出流	OutputStream
我们发现OutputStream是一个抽象类,我们不能对其进行直接实例化,而我们需要使用子类对其进行实例化.那么选择哪个子类呢?
我们现在操作的是文件所以我们选择的是FileOutputStream

public static void main(String[] args) throws IOException {
    FileOutputStream out = new FileOutputStream("a.txt");
    //往文件中写入数据

    //一次写入一个字节
    out.write(97);
    out.write(98);
    out.write(99);
    out.write(100);
    //如果超过了一个字节，就会丢弃掉多余字节
    //out.write(200);
    System.out.println("============================");
    //一次可以写入一个字节数组
    byte[] bytes = {101, 102, 103, 104};
    out.write(bytes);
    //写入中文
    String str="爱生活";
    byte[] bytes1 = str.getBytes();
    //System.out.println(Arrays.toString(bytes1));
    out.write(bytes1);

    //一次写入字节数组的一部分
    //参数2：这个字节的起始索引 参数3：你要写几个字节
    out.write(bytes1,3,6);

    //流使用完毕要记得释放资源
    out.close();
}

2.4_FileOutputStream写出数据(掌握)

A: 构造方法
	FileOutputStream(File file)
	FileOutputStream(String name)
B:案例演示
	FileOutputStream写出数据
	
	注意事项：
		创建字节输出流对象了做了几件事情?
		a:调用系统资源创建a.txt文件
	  	b:创建了一个fos对象
	  	c:把fos对象指向这个文件
		为什么一定要close()?

		a: 通知系统释放关于管理a.txt文件的资源
		b: 让Io流对象变成垃圾,等待垃圾回收器对其回收

2.5_FileOutputStream的三个write()方法(掌握)

A:FileOutputStream的三个write()方法
	public void write(int b):写一个字节  超过一个字节 砍掉前面的字节
	public void write(byte[] b):写一个字节数组
	public void write(byte[] b,int off,int len):写一个字节数组的一部分
B:案例演示:	FileOutputStream的三个write()方法

2.6_FileOutputStream写出数据实现换行和追加写入(掌握)

A:案例演示: FileOutputStream写出数据如何实现数据的换行

windows下的换行符只用是 \r\n
Linux \n
Mac \r

eclipse/IDEA 中的记事本软件以及editplus这样的第三种软件都做了平台的兼容

B:案例演示: FileOutputStream写出数据如何实现数据的追加写入

public static void main(String[] args) throws IOException {
   /* FileOutputStream(File file, boolean append)
    创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

    FileOutputStream(String name, boolean append)
    创建一个向具有指定 name 的文件中写入数据的输出文件流。*/
     //参数2：是否要追加写入，true 追加写入。false 不追加
    FileOutputStream out = new FileOutputStream("c.txt",true);

    out.write("劝君莫取美娇娘，不信你看武大郎".getBytes());
    //写入换行符

  /*  windows下的换行符只用是 \r\n
    Linux \n
    Mac    \r
    */
    out.write("\r\n".getBytes());
    out.write("若是取了美娇娘，时时刻刻也要防，不信你看王宝强".getBytes());
    out.write("\r\n".getBytes());
    out.close();
}

2.7_FileOutputStream写出数据加入异常处理(掌握)

A:案例演示:FileOutputStream写出数据加入异常处理

public static void main(String[] args) {
    //流的异常处理
    FileOutputStream out=null;
    try{
        out = new FileOutputStream("c.txt");
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        try {
            if (out != null) {
                out.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

3_FileInputStream

3.1_FileInputStream读取数据一次一个字节(掌握)

A:案例演示:

int read():一次读取一个字节 ,如果没有数据返回的就是-1

public static void main(String[] args) throws IOException {
   // FileInputStream 从文件系统中的某个文件中获得输入字节。
   /* FileInputStream(File file)
    通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

    FileInputStream(String name)
    通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。*/

   //输入流所关联的文件，如果不存在，就会报错
    FileInputStream in= new FileInputStream("a.txt");

    //输入输入流，读取文件中的数据
    //一次读取一个字节
    int by = in.read();
    System.out.println(by);
    by = in.read();
    System.out.println(by);
    by = in.read();
    System.out.println(by);
    by = in.read();
    System.out.println(by);
    //如果读取不到有效的字节，就会返回-1 ，我们经常使用-1来判断这个文件的数据是否读取完毕。
    by = in.read();
    System.out.println(by);

    //流使用完毕，记得释放资源
    in.close();
}

3.2_FileInputStream读取数据,一次读取一个字节数组(掌握)

public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream(new File("a.txt"));
    //一次可以读取一个 字节数组
    //创建一个字节数组，来充当容器
    byte[] bytes = new byte[1024];
    //把读取到的字节，装进你传进来的这个容器
    int len = in.read(bytes); //返回的是你一次实际读取到的有效字节个数
    System.out.println("读取到的有效字节个数："+len);


    System.out.println(Arrays.toString(bytes));


    //把字节数组转换成字符串
    String s = new String(bytes, 2, len);
    System.out.println(s);

    in.close();
}

A:案例演示:

int read(byte[] b):一次读取一个字节数组
返回的int类型的值表示的意思是读取到的字节的个数,如果没有数据了就返回-1

public static void main(String[] args) throws IOException {
    //很显然一次读写一个字节来复制文件，效率太慢
    //我们一次读写一个字节数组，来进行复制
    FileInputStream in = new FileInputStream("MyTest.java");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\MyTest123.java");
    //定义一个字节数组，来充当缓冲区
    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();
}

3.3_FileInputStream读取数据,一次读取一部分字节

public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream(new File("a.txt"));
    byte[] bytes = new byte[1024];
    //一次从文件中读取3个字节，从0索引处开始把读取到的3个字节放入容器中
    //如果读取不到有效字节返回的是 -1
    int len = in.read(bytes,0,3);

    System.out.println("读取到的有效字节个数：" + len);
    len = in.read(bytes, 0, 3);

    System.out.println("读取到的有效字节个数：" + len);
    len = in.read(bytes, 0, 3);

    System.out.println("读取到的有效字节个数：" + len);

    System.out.println(Arrays.toString(bytes));
    in.close();
}

3.4_FileInputStream读取数据的两种方式比较图解(掌握)

A:画图演示:

FileInputStream读取数据的两种方式比较图解

4_字节流复制文件

4.1_字节流复制文本文件(掌握)

A:案例演示: 字节流一次读写一个字节复制文本文件

分析:

a: 创建字节输入流对象和字节输出流对象
b: 频繁的读写操作
c: 释放资源

public static void main(String[] args) throws IOException {
    //进行文件的复制
    //方式1：读取一个字节，写入一个字节来复制文本文件
    FileInputStream in = new FileInputStream("MyTest.java");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\MyTest.java");
    int by = 0;
    while ((by = in.read()) != -1) {
        out.write(by);
        out.flush();
    }
    //释放资源
    in.close();
    out.close();

4.2_字节流复制MP3(掌握)

A:案例演示: 字节流一次读写一个字节复制MP3

public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\音乐\\音乐\\辛晓琪 - 领悟.mp3");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\辛晓琪 - 领悟.mp3");
    //一次读取一个字节，写入一个字节来复制mp3
    int by = 0;
    long start = System.currentTimeMillis();
    while ((by = in.read()) != -1) {
        out.write(by);
        out.flush();
    }
    long end = System.currentTimeMillis();

    System.out.println("复制完成共耗时"+(end-start)+"毫秒");
    //释放资源
    in.close();
    out.close();
}

4.3_字节流复制文本文件2(掌握)

A:案例演示: 字节流一次读写一个字节数组复制文本文件

public static void main(String[] args) throws IOException {
    //很显然一次读写一个字节来复制文件，效率太慢
    //我们一次读写一个字节数组，来进行复制
    FileInputStream in = new FileInputStream("MyTest.java");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\MyTest123.java");
    //定义一个字节数组，来充当缓冲区
    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();
}

4.4_字节流复制MP3(掌握)

A:案例演示: 字节流一次读写一个字节数组复制MP3

public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\音乐\\音乐\\辛晓琪 - 领悟.mp3");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\辛晓琪 - 领悟2222.mp3");
    //1.定义一个字节数组，充当缓冲区
    byte[] bytes = new byte[1024 * 8];
    //2.定义一个变量。用来记录每次读取到的有效字节个数
    int len = 0;
    //3.频繁的读写
    long start = System.currentTimeMillis();
    while ((len = in.read(bytes)) != -1) {
        out.write(bytes, 0, len);
        out.flush();
    }
    long end = System.currentTimeMillis();

    System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    //释放资源
    // TODO 我今天代码写到这里，明天继续从这里开始写，我要写什么功能
    in.close();
    out.close();
}

4.5_字节流复制MP4

public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream("E:\\课堂录制视频\\录像160.mp4");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\test.mp4");
    byte[] bytes=new byte[1024*8];
    int len=0;
    long start = System.currentTimeMillis();

    while ((len=in.read(bytes))!=-1){
        out.write(bytes,0,len);
        out.flush();
    }
    long end = System.currentTimeMillis();
    System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    in.close();
    out.close();
}

4.6_流的异常处理

public static void main(String[] args) {
    //流的异常处理
    FileInputStream in = null;
    FileOutputStream out = null;
    try {
        //System.out.println(1 / 0);
        in = new FileInputStream("E:\\课堂录制视频\\录像160.mp4");
        out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\test.mp4");
        byte[] bytes = new byte[1024 * 8];
        int len = 0;
        long start = System.currentTimeMillis();
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //释放资源
        try {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

5_BufferedOutputStream

5.1_BufferedOutputStream写出数据(掌握)

A:缓冲思想
	字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
	这是加入了数组这样的缓冲区效果，java本身在设计的时候，
	也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流
B:BufferedOutputStream的构造方法
	查看API
	BufferedOutputStream(OutputStream out)
C:案例演示
	BufferedOutputStream写出数据

5.2_BufferedInputStream读取数据(掌握)

A:BufferedInputStream的构造方法

查看API
BufferedInputStream(InputStream in)

B:案例演示

BufferedInputStream读取数据

public static void main(String[] args) throws IOException{
    //高效的字节输入输出流
    //BufferedInputStream
    //BufferedOutputStream

    //test1(); //复制完成共耗时26813毫秒
    //test2();//复制完成共耗时16099毫秒

    //test3();
    //test4();
}

private static void test4() throws IOException{
    BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\ShenMouMou\\Music\\音乐\\音乐\\辛晓琪 - 领悟.mp3"));
    BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\辛晓琪 - 领悟buffer.mp3"));

    //一次读取一个字节，写入一个字节来复制mp3
    byte[] bytes = new byte[1024 * 8];
    int by = 0;
    long start = System.currentTimeMillis();
    while ((by = in.read(bytes)) != -1) {
        out.write(bytes,0,by);
        out.flush();
    }
    long end = System.currentTimeMillis();

    System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    //释放资源
    in.close();
    out.close();
}

private static void test3() throws IOException{
    FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\音乐\\音乐\\辛晓琪 - 领悟.mp3");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\辛晓琪 - 领悟2222.mp3");
    //1.定义一个字节数组，充当缓冲区
    byte[] bytes = new byte[1024 * 8];
    //2.定义一个变量。用来记录每次读取到的有效字节个数
    int len = 0;
    //3.频繁的读写
    long start = System.currentTimeMillis();
    while ((len = in.read(bytes)) != -1) {
        out.write(bytes, 0, len);
        out.flush();
    }
    long end = System.currentTimeMillis();

    System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    //释放资源
    in.close();
    out.close();
}

private static void test2() throws IOException{
 /*   BufferedInputStream(InputStream in)
    创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

    BufferedOutputStream(OutputStream out)
      创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
    */
    BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\ShenMouMou\\Music\\音乐\\音乐\\辛晓琪 - 领悟.mp3"));
    BufferedOutputStream out= new BufferedOutputStream(new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\辛晓琪 - 领悟buffer.mp3"));

    //一次读取一个字节，写入一个字节来复制mp3
    int by = 0;
    long start = System.currentTimeMillis();
    while ((by = in.read()) != -1) {
        out.write(by);
        out.flush();
    }
    long end = System.currentTimeMillis();

    System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    //释放资源
    in.close();
    out.close();
}

private static void test1() throws IOException {
    FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\音乐\\音乐\\辛晓琪 - 领悟.mp3");
    FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\辛晓琪 - 领悟.mp3");
    //一次读取一个字节，写入一个字节来复制mp3
    int by = 0;
    long start = System.currentTimeMillis();
    while ((by = in.read()) != -1) {
        out.write(by);
        out.flush();
    }
    long end = System.currentTimeMillis();

    System.out.println("复制完成共耗时" + (end - start) + "毫秒");
    //释放资源
    in.close();
    out.close();
}