20.IO流（字节流）

最新推荐文章于 2022-03-28 15:40:33 发布

可儿可爱

最新推荐文章于 2022-03-28 15:40:33 发布

阅读量125

点赞数

文章标签： javascript 开发语言 ecmascript

本文链接：https://blog.csdn.net/weixin_62520626/article/details/121675005

版权

1.IO流概述及其分类

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

2.IO流基类概述和FileOutputStream的构造方法

1.IO流基类概述
   a:字节流的抽象基类：
       InputStream ，OutputStream。
   b:字符流的抽象基类：
       Reader ， Writer。
   注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
   如：InputStream的子类FileInputStream。
   如：Reader的子类FileReader。
2.FileOutputStream的构造方法
   由一个案例引出使用IO流写数据，由于字节流先出现就先学习字节输出流基类OutputStream，
   使用具体子类FileOutputStream

Io流的分类:
- (1): 按照流向进行划分
        输入流
        输出流
- (2): 按照操作的数据类型进行划分
- 字节流
- 字节输入流   InputStream       读
- 字节输出流   OutputStream   写
- 字符流
- 字符输入流    Reader           读
- 字符输出流   Writer           写
-
- 需求:   往一个文本文件中写一串数据 Hello,IO
- 分析:
- a: 我们现在操作的是文本文件,所有按照我们的想法,我们优先现在字符流,但是字节流是优先于字符流. 所以先使用字节流
- b: 因为我们要写数据,所以我们应该使用字节流中输出流   OutputStream
- 我们发现OutputStream是一个抽象类,我们不能对其进行直接实例化,而我们需要使用子类对其进行实例化.那么选择哪个子类呢?
- 我们现在操作的是文件所以我们选择的是FileOutputStream

3.FileOutputStream写出数据

1.构造方法
   FileOutputStream(File file)
   FileOutputStream(String name)
2.案例演示
   FileOutputStream写出数据

   注意事项：
       创建字节输出流对象了做了几件事情?
       a:调用系统资源创建a.txt文件
       b:创建了一个fos对象
       c:把fos对象指向这个文件
       为什么一定要close()?

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

构造方法：

public class MyTest {
    public static void main(String[] args) throws IOException {
        // FileOutputStream 文件输出流，将字节数据写入到文件中
        // 构造方法摘要
        // FileOutputStream(File file)
        // 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

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


        //输出流所关联的文件，如果不存在，则自动创建
        FileOutputStream out = new FileOutputStream("a.txt");


        File file = new File("b.txt");
        //file.createNewFile();
        FileOutputStream fileOutputStream = new FileOutputStream(file);

    }
}

4.FileOutputStream的三个write()方法

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

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        //输出流所关联的文件，如果不存在，则自动创建
        FileOutputStream out = new FileOutputStream("a.txt");
        //往文件中写入数据
        out.write(99); //一次写入一个字节
        out.write(100); //一次写入一个字节
        out.write(101); //一次写入一个字节
        //out.write(500);//超过一个字节，会丢弃掉多余字节
        /*
        *  -26
            -120
            -111
        * */
        out.write(-26);
        out.write(-120);
        out.write(-111);

        out.close();
    }
}

public class MyTest3 {
    public static void main(String[] args) throws IOException {
        //输出流所关联的文件，如果不存在，则自动创建
        FileOutputStream out = new FileOutputStream("b.txt");
        //一次写入一个字节数组
        byte[] bytes = {99, 98, 97, 100};
        out.write(bytes);
        //一次写入字节数组的一部分 从0索引处开始写入两个字节
        out.write(bytes,0,2);

        byte[] bytes1 = "好好学习".getBytes();
        out.write(bytes1);
        out.write(bytes1,0,12);
        //流使用完毕之后，一定要记得关闭流
        //关闭此文件输出流并释放与此流有关的所有系统资源。此文件输出流不能再用于写入字节。
        out.close();
        
    }
}

5.FileOutputStream写出数据实现换行和追加写入

1.FileOutputStream写出数据如何实现数据的换行

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

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

2.FileOutputStream写出数据如何实现数据的追加写入

换行：\n\r

public class MyTest4 {
    public static void main(String[] args) throws IOException {
        //输出流所关联的文件，如果不存在，则自动创建
        /*
        *
        *  windows下的换行符是 \r\n
		  Linux		\n
 		  Mac		\r
        * */
        FileOutputStream fos = new FileOutputStream("a.txt");
        fos.write("去年今日此门中,".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("人面桃花相映红。".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("人面不知何处去,".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("桃花依旧笑春风。".getBytes());
        fos.write("\r\n".getBytes());

        /*
        *  创建字节输出流对象了做了几件事情?
		a:调用系统资源创建a.txt文件
	  	b:创建了一个fos对象
	  	c:把fos对象指向这个文件
		为什么一定要close()?

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

        fos.close();
    }
}

追加写入：

public class MyTest5 {
    public static void main(String[] args) throws IOException {
        //输出流所关联的文件，如果不存在，则自动创建
        // FileOutputStream(String name, boolean append)
        // 创建一个向具有指定 name 的文件中写入数据的输出文件流
        //true 表示追加写入
        FileOutputStream fos = new FileOutputStream("a.txt",true);
        fos.write("去年今日此门中,".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("人面桃花相映红。".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("人面不知何处去,".getBytes());
        fos.write("\r\n".getBytes());
        fos.write("桃花依旧笑春风。".getBytes());
        fos.write("\r\n".getBytes());

        fos.close();
    }
}

6.FileOutputStream写出数据加入异常处理

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

7.FileInputStream读取数据一次一个字节

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

FileInputStream构造方法：

public class MyTest {
    public static void main(String[] args) throws FileNotFoundException {
        //  FileInputStream 从文件中读取字节数据
       /* FileInputStream(File file)
        通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

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

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

        File file = new File("b.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

    }
}

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        //输入流，所关联的文件，如果找不到就报错
        FileInputStream in = new FileInputStream("b.txt");
        //一次读取一个字节，如果读取不到，返回 -1 我们经常用 -1来做判断，判断文件是否读取完毕。
        int data = in.read();
        System.out.println(data);
        data = in.read();
        //char ch= (char) data;
        //System.out.println(ch);
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);
        data = in.read();
        System.out.println(data);

        in.close();

        /*FileOutputStream out= new FileOutputStream("e.txt");
        out.write(228);
        out.write(189);
        out.write(160);
        out.close();*/

    }
}

8.FileInputStream读取数据一次一个字节数组

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

public class MyTest3 {
    public static void main(String[] args) throws IOException {
        //输入流，所关联的文件，如果找不到就报错
        FileInputStream in = new FileInputStream("a.txt");
        //创建一个字节数组，充当缓冲区
        byte[] bytes = new byte[1024*8];
        //len 每次读取到的有效字节个数,如果读取不到返回-1
        int len = in.read(bytes);
        System.out.println(len);
        len = in.read(bytes);
        System.out.println(len);

        String s = new String(bytes);
        System.out.println(s);
    }
}

public class MyTest4 {
    public static void main(String[] args) throws IOException {
        //输入流，所关联的文件，如果找不到就报错
        FileInputStream in = new FileInputStream("a.txt");
        //创建一个字节数组，充当缓冲区
        byte[] bytes = new byte[1024];
        //len 每次读取到的有效字节个数,如果读取不到返回-1
        //每次读取100个字节填充到缓冲区中
        int len = in.read(bytes,0,100);
        System.out.println(len); // len 每次读取到的有效字节个数,如果读取不到返回-1
        for (byte aByte : bytes) {
            System.out.println(aByte);
        }

        in.close();

    }
}

9.字节流复制文本文件

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

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

public class MyTest {
    public static void main(String[] args) throws IOException {
        //复制文件：采用读一个字节，写一个字节，这种方式太慢，不推荐，我们演示一下
        FileInputStream in = new FileInputStream("a.txt");
        FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\a.txt");
         int data=0;
        while ((data=in.read())!=-1){
            out.write(data);
        }
        in.close();
        out.close();
    }
}

10.字节流复制MP3

字节流一次读写一个字节复制MP3

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        //复制文件：采用读一个字节，写一个字节，这种方式太慢，不推荐，我们演示一下
        FileInputStream in = new FileInputStream("人生 夏小虎.mp3");
        FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\aa.mp3");
        int data = 0;
        while ((data = in.read()) != -1) {
            out.write(data);
        }
        System.out.println("复制完毕");
        in.close();
        out.close();
    }
}

11.FileInputStream读取数据的两种方式比较

复制文本文件时很快，复制比如一些音乐文件时很慢，一个字节一个字节的读取，循环很多次。

12.字节流复制MP3

字节流一次读写一个字节数组复制MP3

public class MyTest3 {
    public static void main(String[] args) throws IOException {
        //很显然一次读写一个字节，复制文件，太慢，不推荐使用。
        //我们推荐使用第一次读写一个字节数组的方式，来复制文件。

        FileInputStream in = new FileInputStream("人生 夏小虎.mp3");
        FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\aa.mp3");
        byte[] bytes = new byte[1024 * 8];
        int len = 0; //实际每次读取到的有效字节个数
        int count=0;
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes,0,len);
            count++;
            System.out.println(count+"次数");
        }
        System.out.println("复制完毕");
        in.close();
        out.close();
    }
}

13.FileOutputStream写出数据加入异常处理

public class MyTest {
    public static void main(String[] args) {
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream("人生 夏小虎.mp3");
            out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\aa.mp3");
            byte[] bytes = new byte[1024 * 8];
            int len = 0; //实际每次读取到的有效字节个数
            while ((len = in.read(bytes)) != -1) {
                out.write(bytes, 0, len);
                out.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

14.BufferedOutputStream写出数据

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

15.BufferedInputStream读取数据

1.BufferedInputStream的构造方法
   查看API
   BufferedInputStream(InputStream in)
2.案例演示
   BufferedInputStream读取数据

16.字节流四种方式复制MP3并测试效率

案例演示
   通过以下四个代码测试效率。
   基本字节流一次读写一个字节
   基本字节流一次读写一个字节数组
   高效字节流一次读写一个字节
   高效字节流一次读写一个字节数组

基本字节流和高效字节流一次只读一个字节：

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

      /*  BufferedInputStream(InputStream in)
        创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
        BufferedInputStream(InputStream in, int size)
        创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。*/


      /*  构造方法摘要
        BufferedOutputStream(OutputStream out)
        创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        BufferedOutputStream(OutputStream out, int size)
        创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。*/
        //test1(); //耗时：16211毫秒
        test2(); //耗时：95毫秒

    }

    private static void test2() throws IOException {
        long start = System.currentTimeMillis();
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("新上海滩 - 上海滩.mp3"));

        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\bb.mp3"));
        int data = 0;
        while ((data = in.read()) != -1) {
            out.write(data);
        }
        in.close();
        out.close();
        long end = System.currentTimeMillis();

        System.out.println("耗时："+(end-start)+"毫秒");

    }

    private static void test1() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream in = new FileInputStream("新上海滩 - 上海滩.mp3");
        FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\cc.mp3");
        int data = 0;
        while ((data = in.read()) != -1) {
            out.write(data);
        }
        in.close();
        out.close();

        long end = System.currentTimeMillis();

        System.out.println("耗时：" + (end - start) + "毫秒");
    }
}

基本字节流和高效字节流一次读写一个数组：

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

      /*  BufferedInputStream(InputStream in)
        创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
        BufferedInputStream(InputStream in, int size)
        创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。*/


      /*  构造方法摘要
        BufferedOutputStream(OutputStream out)
        创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        BufferedOutputStream(OutputStream out, int size)
        创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。*/
        //test1(); //耗时：16211毫秒  耗时：7毫秒
        test2(); //耗时：95毫秒 耗时：98毫秒 耗时：8毫秒

    }

    private static void test2() throws IOException {
        long start = System.currentTimeMillis();
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("新上海滩 - 上海滩.mp3"));
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\bb.mp3"));
        int len = 0;
        byte[] bytes = new byte[1024 * 8];
        while ((len= in.read(bytes)) != -1) {
            out.write(bytes,0,len);
        }
        in.close();
        out.close();
        long end = System.currentTimeMillis();

        System.out.println("耗时："+(end-start)+"毫秒");

    }

    private static void test1() throws IOException {
        long start = System.currentTimeMillis();
        FileInputStream in = new FileInputStream("新上海滩 - 上海滩.mp3");
        FileOutputStream out = new FileOutputStream("C:\\Users\\ShenMouMou\\Desktop\\cc.mp3");
        byte[] bytes = new byte[1024 * 8];
        int len = 0;
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes,0,len);
        }
        in.close();
        out.close();

        long end = System.currentTimeMillis();

        System.out.println("耗时：" + (end - start) + "毫秒");
    }
}

可儿可爱

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
20.IO流（字节流）

1.IO流概述及其分类1.IO流概述 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 java.io2.IO流分类 a:按照数据流向站在内存角度输入流读入数据输出流写出数据 b:按照数据类型字节流可以读写任何类型的文件比如音频视频文本文件字符流只能读写文本文件什么情况下使用哪种流呢?...
复制链接

扫一扫