JavaSE IO流

最新推荐文章于 2023-05-26 06:05:20 发布

Hoooooope!

最新推荐文章于 2023-05-26 06:05:20 发布

阅读量68

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_43563187/article/details/112725289

版权

JavaSE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

day20目录：

IO流

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

在这里插入图片描述

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

20.08_IO流(IO流基类概述和FileOutputStream的构造方法)(掌握)

在这里插入图片描述

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



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

20.09_IO流(FileOutputStream写出数据)(掌握)

A: 构造方法
	FileOutputStream(File file)
	FileOutputStream(String name)
B:案例演示
	FileOutputStream写出数据

public class MyTest {
    public static void main(String[] args) throws IOException {
        // FileOutputStream 文件输出流
        //文件输出流是用于将数据写入 File。
      /*  FileOutputStream(File file)
        创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
        FileOutputStream(String name)
        创建一个向具有指定名称的文件中写入数据的输出文件流。


         FileOutputStream(File file, boolean append)
        创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

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

        File file = new File("a.txt");
      /* if (!file.exists()) {
            file.createNewFile();
        }*/
        //创建一个输出流，关联一个文件,文件输出流所关联的文件如果不存在会自动创建
        FileOutputStream out = new FileOutputStream(file);		
           /* FileOutputStream(String name)
        创建一个向具有指定名称的文件中写入数据的输出文件流。*/

        FileOutputStream fileOutputStream = new FileOutputStream("b.txt");


    }
}

	注意事项：
		创建字节输出流对象了做了几件事情?
		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 out = new FileOutputStream("a.txt");
        //使用输出流，往文件中写入数据
        out.write(97);
        out.write(98);
        out.write(99);
        //一次写入一个字节，如果超过一个字节，会丢弃掉多余字节。
        // out.write(200);
        byte[] bytes = {100, 101, 102, 103};
        out.write(bytes);
        //一次可以写入字节数组的一部分。参数1：数组中元素索引，参数2，个数
        out.write(bytes, 0, 2);

        out.write(bytes, 1, 3);

        byte[] bytes1 = "我".getBytes();
        // [-26, -120, -111]
        System.out.println(Arrays.toString(bytes1));
        out.write(bytes1);
        out.write(-26);
        out.write(-120);
        out.write(-111);

        byte[] bytes2 = "我爱你中国".getBytes();
        out.write(bytes2);

       /* 方法摘要
        void close ()
        关闭此文件输出流并释放与此流有关的所有系统资源。
*/
        //当你流使用完毕之后，一定记得释放资源
        out.close();
    }
}

20.10_IO流(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()方法

20.11_IO流(FileOutputStream写出数据实现换行和追加写入)(掌握)

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

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

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



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

public static void main(String[] args) throws IOException {
        //参数2：是否追加写入，true 就是追加写入，false就是不追加写入
        FileOutputStream out = new FileOutputStream("b.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.write("人面不知何处去".getBytes());
        out.write("\r\n".getBytes());
        out.write("桃花依旧笑春风".getBytes());
        out.write("\r\n".getBytes());
        //关闭流
        out.close();

    }

20.12_IO流(FileOutputStream写出数据加入异常处理)(掌握)

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

public class MyTest2 {
    public static void main(String[] args) {
        FileOutputStream out = null;
        try {
            // System.out.println(1 / 0);
            //流的异常处理
            out = new FileOutputStream("c.txt");
            out.write("但愿你的眼睛，只看得到笑容".getBytes());
            out.write("\r\n".getBytes());
            out.write("但愿你流下每一滴泪，都让人感动".getBytes());
            out.write("\r\n".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            try {
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        System.out.println("下面的代码");
        System.out.println("下面的代码");
        System.out.println("下面的代码");
    }
}

20.13_IO流(FileInputStream读取数据一次一个字节)(掌握)

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

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

        // FileNotFoundException:c.txt(系统找不到指定的文件。)
        //输入流，所关联的文件，如果不存在，就会报错
        FileInputStream in = new FileInputStream(new File("a.txt"));
        //读取文件中的数据
        //一次读取一个字节，如果读取不到，返回-1 我们就可以使用 -1 来判断这个文件是否读取完了。
        int by = in.read();
        System.out.println(by);
        by = in.read();
        char ch = (char) by;
        System.out.println(ch);
        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);
        by = in.read();
        System.out.println(by);
        by = in.read();
        System.out.println(by);

        //使用完毕，记得关闭流
        in.close();


    }
}

public class MyTest2 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("b.txt");
        //定义一个字节数组，来充当这个缓冲区
        byte[] bytes = new byte[1024 * 1024];
        //一次读取多个字节，填满到你给的这个字节数组中，返回的是读取到的有效的字节个数
        int len = in.read(bytes);
        System.out.println(len);
        String s = new String(bytes, 0, len);
        System.out.println(s);

        in.close();
    }
}

public class MyTest3 {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("b.txt");
        //定义一个字节数组，来充当这个缓冲区
        byte[] bytes = new byte[1024];
        //一次读取你指定的一部分字节，填充到你给的缓冲区当中
        //从0索引处开始填充3个字节
        int len = in.read(bytes, 0, 3);
        for (byte aByte : bytes) {
            System.out.println(aByte);
        }
         String s = new String(bytes, 0, len);
        System.out.println(s);

        in.close();


    }
}

20.14_IO流(字节流复制文本文件)(掌握)

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

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

20.15_IO流(字节流复制MP3)(掌握)

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

	public class MyTest {
    public static void main(String[] args) throws IOException {
        //复制一个文本文件
        //封装源文件
        File file = new File("MyTest.java");
        FileInputStream in = new FileInputStream(file);
        //封装目标文件
        FileOutputStream out = new FileOutputStream(new File("C:\\Users\\ShenMouMou\\Desktop\\", file.getName()));
        //一次读取一个字节，写入一个字节来复制
        int by = 0; //定义一个变量，用来记录，每次读取到字节
        while ((by = in.read()) != -1) {
            out.write(by);
        }
      /*
        while (true) {
            int by = in.read();
            if (by == -1) {
                break;
            }
            out.write(by);
        }*/
        in.close();
        out.close();
    }
}

20.16_IO流(FileInputStream读取数据一次一个字节数组)(掌握)

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

20.17_IO流(FileInputStream读取数据的两种方式比较图解)(掌握)

A:画图演示:	FileInputStream读取数据的两种方式比较图解

20.18_IO流(字节流复制文本文件2)(掌握)

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

public class MyTest {
    public static void main(String[] args) throws IOException {
        //很显然一次读写一个字节，来进行文件的复制，效率太低，你应该一次读取一个字节数组，来进行复制。
        FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\夜夜夜夜.mp3");
        FileOutputStream out = new FileOutputStream("E:\\夜2222.mp3");
        //创建一个数组来充当缓冲区

        byte[] bytes = new byte[1024 * 8];
        //返回的是读取的到有效的字节个数
        int len = 0; //定义一个变量，来接收每次读取到的有效的字节个数
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
            System.out.println("正在复制...");
        }

      /*  while (true) {
            int len = in.read(bytes);
            if (len == -1) {
                break;
            }
            out.write(bytes, 0, len);
        }*/
        in.close();
        out.close();
        System.out.println("复制完毕");
    }
}

20.19_IO流(字节流复制MP3)(掌握)

A:案例演示:	字节流一次读写一个字节数组复制MP3 ：抓取异常

public class MyTest2 {
    public static void main(String[] args) {
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            //很显然一次读写一个字节，来进行文件的复制，效率太低，你应该一次读取一个字节数组，来进行复制。
            in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\夜夜夜夜.mp3");
            out = new FileOutputStream("E:\\夜2222.mp3");
            //创建一个数组来充当缓冲区
            byte[] bytes = new byte[1024 * 8];
            //返回的是读取的到有效的字节个数
            int len = 0; //定义一个变量，来接收每次读取到的有效的字节个数
            while ((len = in.read(bytes)) != -1) {
                out.write(bytes, 0, len);
                out.flush();
                System.out.println("正在复制...");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (out != null) {
                    out.close();
                }
                System.out.println("复制完毕");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

20.20_IO流(BufferedOutputStream写出数据)(掌握)

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

public class MyTest {
    public static void main(String[] args) throws IOException {
       /* 该类实现缓冲的输出流。通过设置这种输出流，
        应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。*/
        //高效的字节输入输出流
        // BufferedInputStream
        //   BufferedOutputStream

        //构造方法
        // BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
        /*BufferedInputStream(InputStream in)
        创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。*/

        long start = System.currentTimeMillis();
        copyFile();  //耗时53364毫秒 耗时23毫秒
        copyFile2();  //耗时36998毫秒  耗时31毫秒
        long end = System.currentTimeMillis();

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

    }

    private static void copyFile2() throws IOException {
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\ShenMouMou\\Music\\夜夜夜夜.mp3"));
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("E:\\333.mp3"));
        //自己定义一个缓冲区
        byte[] bytes = new byte[1024 * 8];
        int len = 0;
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
            System.out.println("正在复制...");
        }
        //惰性   自私性   自律性     独立
        in.close();
        out.close();
    }

    private static void copyFile() throws IOException {
        FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Music\\夜夜夜夜.mp3");
        FileOutputStream out = new FileOutputStream("E:\\夜夜夜夜.mp3");
        byte[] bytes = new byte[1024 * 8];
        int len = 0;
        while ((len = in.read(bytes)) != -1) {
            out.write(bytes, 0, len);
            out.flush();
            System.out.println("正在复制...");
        }
        in.close();
        out.close();
    }
}
//结论：如果两个方法都定义缓冲区了那读取的速率差别不大；如果都不定义缓冲区，第一种方法明显快于第二种

20.21_IO流(BufferedInputStream读取数据)(掌握)

A:BufferedInputStream的构造方法
	查看API
	BufferedInputStream(InputStream in)
B:案例演示
	BufferedInputStream读取数据

20.22_IO流(字节流四种方式复制MP3并测试效率)(掌握)

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

20.23_day20总结

Hoooooope!

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE IO流

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

扫一扫

专栏目录