java语言--------javaSE之IO流基类

最新推荐文章于 2022-07-09 10:54:13 发布

*咚咚咚*

最新推荐文章于 2022-07-09 10:54:13 发布

阅读量174

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_49522417/article/details/108027683

版权

IO流基类

IO流概述及其分类

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

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

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

 //字节输出流
   //FileOutputStream 文件输出流是用于将数据写入 File 或 的输出流。
/*   FileOutputStream(File file)
   创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

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

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

FileOutputStream写出数据

构造方法
FileOutputStream(File file)
FileOutputStream(String name)

public static void main(String[] args) throws IOException {
   /* FileOutputStream(File file)
    创建一个向指定 File 对象表示的文件中写入数据的文件输出流。*/
    File file = new File("a.txt");
    //file.createNewFile();
    //输出流所关联的文件，如果不存在，会自动帮你创建。
    FileOutputStream out = new FileOutputStream(file);
   /* FileOutputStream(String name)
    创建一个向具有指定名称的文件中写入数据的输出文件流。*/
    FileOutputStream out2 = new FileOutputStream("b.txt");
}

FileOutputStream的三个write()方法

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

public static void main(String[] args) throws IOException {
    FileOutputStream out = new FileOutputStream("a.txt");
    //一次写入一个字节
    out.write(97);
    out.write(98);
    out.write(99);
    //一次写入一个字节数组
    byte[] bytes = "像我这样优秀的人，本该灿烂过一生，怎么二十多年到头来，还在人海里浮沉。".getBytes();
    out.write(bytes);
    //一次写入字节数组的一部分 0 从字节数组中的那个索引开始 24 写24个字节。
    /*windows下的换行符只用是 \r\n
    Linux     \n
    Mac       \r*/
    out.write(bytes,0,24);
    //写入换行符
    out.write("\r\n".getBytes());
    out.write(bytes);
    //流使用完毕，记得要关闭。
    out.close();

}

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

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

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

Mac \r

public static void main(String[] args) throws IOException {
    //参2：是否追加写入，true 就是追加写入，false 就是默认覆盖。
    FileOutputStream out = new FileOutputStream("b.txt",true);
    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.write("桃花依旧笑春风".getBytes());
    out.write("\r\n".getBytes());
    //释放资源
    out.close();
}

FileOutputStream写出数据加入异常处理

public static void main(String[] args) {
    //流的异常处理
    FileOutputStream out=null;
    try {
       // System.out.println(1/0);
        out = new FileOutputStream("a.txt");
        out.write(100);
    }catch (IOException e){
        e.printStackTrace();
    }finally {
        //释放资源
        try {
            if (out != null) {
                out.close();
            }

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

}

FileInputStream读取数据一次一个字节

public static void main(String[] args) throws IOException {
   // FileInputStream 从文件系统中的某个文件中获得输入字节

   /* 构造方法摘要
    FileInputStream(File file)
    通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

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

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

    //读取文件中的数据
    //一个读取一个字节
    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);
    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();

}

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

public static void main(String[] args) throws IOException {
    FileInputStream in = new FileInputStream("c.txt");
    //定义一个数组，来充当一个容器
    byte[] bytes = new byte[1024];
    //一个读取换一个字节数组 ，返回的是 实际读取到子节个数
    int len = in.read(bytes);

    System.out.println(len);

    System.out.println("=================================");
    for (byte aByte : bytes) {
        System.out.println(aByte);
    }

    System.out.println("===================================");
    String s = new String(bytes, 0, len);
    System.out.println(s);

    in.close();

}

字节流复制文本文件

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

分析:

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

c: 释放资源

public static void main(String[] args) throws IOException {
    //读取一个字节，写入一个字节，来复制文本文件。
    FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Desktop\\MyTest.java");
    File file = new File("E:\\test");
    if (!file.exists()) {
        file.mkdirs();
    }
    FileOutputStream out = new FileOutputStream(new File(file, "MyTest.java"));
    //定义一个变量用来记录每次读取到的字节
    int by=0;
    while ((by=in.read())!=-1){
        out.write(by);
        out.flush();
    }

    //释放资源
    in.close();
    out.close();

    System.out.println("复制完成");

}

字节流复制MP3

public static void main(String[] args) throws IOException {
    //很显然 一次复制一个字节，太慢。
    FileInputStream in = new FileInputStream("C:\\Users\\ShenMouMou\\Desktop\\a.mp3");
    FileOutputStream out = new FileOutputStream("E:\\test\\情书.mp3");
    int by=0;
    while ((by=in.read())!=-1){
        out.write(by);
        out.flush();
    }

    in.close();
    out.close();

    System.out.println("复制完成");


}

BufferedInputStream读取数据

BufferedInputStream的构造方法
BufferedInputStream(InputStream in)

BufferedOutputStream写出数据

BufferedInputStream读取数据

缓冲思想
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
这是加入了数组这样的缓冲区效果，java本身在设计的时候，
也考虑到了这样的设计思想，所以提供了字节缓冲区流
BufferedOutputStream的构造方法
BufferedOutputStream(OutputStream out)

/*  BufferedInputStream(InputStream in)
  创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。*/
    BufferedInputStream in = new BufferedInputStream(new FileInputStream("C:\\Users\\ShenMouMou\\Desktop\\a.mp3"));

  /*  BufferedOutputStream(OutputStream out)
    创建一个新的缓冲输出流，以将数据写入指定的底层输出流。*/
    BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("E:\\test\\b.mp3"));
    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();