IO流学习小结

本少爷头发还长

已于 2023-03-17 10:54:35 修改

阅读量125

点赞数

文章标签：学习 java 开发语言 Powered by 金山文档

于 2023-03-10 10:22:25 首次发布

本文链接：https://blog.csdn.net/qq_52126327/article/details/129354791

版权

IO流的基本概念

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

IO流的分类

按照数据的流向

输入流：读数据

输出流：写数据

按照数据类型来分

字节流

字节输入流

字节输出流

字符流

字符输入流

字符输出流

IO流的使用场景

如果操作的是纯文本文件，优先使用字符流

如果操作的是图片、视频、音频等二进制文件。优先使用字节流

如果不确定文件类型，优先使用字节流。字节流是万能的流

字节流写数据

FileOutputStream

FileOutputStream 是 OutPutStream的子类，文件输入流用于讲数据写入File

FileOutputStream(String name) : 创建文件输出流以指定的名称写入文件

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

创建一个FileOutputStream对象，构造方法中传递写入数据的目的地。

调用FileOutputStream对象中的方法write，把数据写入到文件中

释放资源（流使用会占用一定的内存，使用完毕要把内存清空，提高程序的效率）。

new FileOutputStream（”路径“）在底层做的其实是新建一个File类

public FileOutputStream(String name) throws FileNotFoundException {

this(name != null ? new File(name) : null, false);

}

字节流写数据的三种方式

方法名	说明
void write(int b)	将指定的字节写入此文件输出流一次写一个字节数据
void write(byte[] b)	将 b.length字节从指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[] b, int off, int len)	将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据

通过write（）方法写入的文件，输入的是字节，也可以通过字节数组的方式写入文件

//也能在其他文件夹中创建，但是必须把绝对路径名写出来，相对路径名，模块名可以存
FileOutputStream fox = new FileOutputStream("File_and_IO\\test01.txt");
//一次写一个字节
fox.write(15);
//如果通过byte数组写入文件，可以使用两个方法：
//方法一：直接定义字符数组
byte[] bytes = {97,98,99,100,101};
fox.write(bytes);
//方法二：可以使用String类中的getBytes()方法！
byte[] bytes1 = "HelloWord!".getBytes();
fox.write(bytes1);

换行操作

实现换行操作，现在只用\n,Windows也能识别换行符！之前Windows系统识别的是\r\n

FileOutputStream fox = new FileOutputStream("File_and_IO\\Demo03.txt");
byte[] bytes = "HelloWorld!\n".getBytes();
byte[] bytes1 = "Learning!".getBytes();
fox.write(bytes);
fox.write(bytes1);
fox.close();

若要实现在原有的文件中再添加数据，而不把之前的数据覆盖掉，使用FileOutputStream（String name ,boolean append）,创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

FileOutputStream fox = new FileOutputStream("File_and_IO\\Demo03.txt" , true);
byte[] bytes = "HelloWorld!\n".getBytes();
byte[] bytes1 = "Learning!\n".getBytes();
fox.write(bytes);
fox.write(bytes1);
for (int i = 0; i < 10; i++) {
    fox.write("hello".getBytes());
    fox.write("\n".getBytes());
}
fox.close();

字节流写数据加异常处理

字节流在写数据过程中两种异常处理都可以

可以直接向上抛出，也可以自己通过try-catch-finally处理

示例代码

  //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("File_and_IO\\fos.txt");
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

字节流读数据(一次读一个字节数据)

FIleInputStream

字节输入流

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

字节输入流读取数据的步骤

创建字节输入流对象

调用字节输入流对象的读数据方法

释放资源

FileInputStream fis = new FileInputStream("File_and_IO\\Demo03.txt");
//读取的是文件中的第一个字符的ASCLL码，如果要将所有数据都读出来，要一直读数据，要查看写了啥，要有一个强转才能查看
System.out.println(fis.read());
//再次读数据就会读到下一个数据
System.out.print((char) fis.read());
如果到达文件末尾，则读取的为-1，所以可以通过循环，进行读数据，在读取为-1时循环停止
public class InputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("File_and_IO\\Demo03.txt");
        int by = fis.read();
        while (true)
        {
            if(by == (-1))
            {
                break;
            }
            System.out.print((char) by);
            by = fis.read();
        }
         //释放资源
        fis.close();
    }
}
改进循环：
public class InputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("File_and_IO\\Demo03.txt");
        int by = fis.read();
        while (by != -1)
        {
            System.out.print((char) by);
            by = fis.read();
        }
         //释放资源
        fis.close();
    }
}

还可以再次改进：

public class InputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("File_and_IO\\Demo03.txt");
        //把上面的第一读取放到while里，就可以只写一句，不用写在方法体中
        int by ;
        while((by = fis.read()) != -1)
        {
            //可以不用认为添加换行，如果文件中有换行，会被识别出来
            System.out.print((char) by);
        }
         //释放资源
        fis.close();
    }
}

字节流复制文本文件

案例需求

把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”

实现步骤

复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

数据源：

E:\itcast\窗里窗外.txt --- 读数据 --- InputStream --- FileInputStream

目的地：

myByteStream\窗里窗外.txt --- 写数据 --- OutputStream --- FileOutputStream

//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("File_and_IO\\Demo03.txt");
//根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("File_and_IO\\Demo04.txt");

//读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
int by;
while ((by=fis.read())!=-1) {
    fos.write(by);
}

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

发现了个问题：

2023/3/2 Windows 10操作系统中

利用FileOutputStream（）创建文件并且添加内容后，里面的\n是可以被Windows自带的文本文档识别的，也就是说存入的只是一个\n（转行）字符，如下代码：

FileOutputStream fox = new FileOutputStream("File_and_IO\\fileOut04.txt");
byte[] bytes = "Hello\n".getBytes();
byte[] bytes1 = "Learn\n".getBytes();
fox.write(bytes);
fox.write(bytes1);
fox.close();

之后通过FileInputStream（）去读取该程序时，若我们使用byte字符数组输出，识别到的也只是一个\n

FileInputStream fis = new FileInputStream("File_and_IO\\fileOut04.txt");
byte[] bytes = new byte[5];
int by = fis.read(bytes);
System.out.println(by);
System.out.println(new String(bytes));
by = fis.read(bytes);
System.out.println(by);
System.out.println(new String(bytes));

如果我们直接新建txt文件，内容也是hello换行learn,则通过上述代码读取该文件，它会多识别出\r\n

操作系统中识别换行符：

windows:\r\n

linux:\n

mac:\r

总结：FileOutputStream在写入数据时:\n也能被识别（通过系统记事本打开它也是换行的）；而我们如果在记事本中输入后直接换行，在FIleInputStream中读取的时候会读取\r\n；所以在我们写程序的时候需要注意，假如你txt写入的数据是通过FileOutputStream写的，换行只是一个字符。如果用记事本写的，换行会是两个字符。好的我又发现了一个问题，如果在idea2020里面写，他也只能识别一个换行

字符流

因为字节流操作中文不方便，所以Java就提供字符流

字符流=字节流+编码表

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

编码表

什么是字符集

是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

常见的字符集

ASCII字符集：

lASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)

基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

GBXXX字符集：

GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

Unicode字符集：

UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码

编码规则：

128个US-ASCII字符，只需一个字节编码

拉丁文等字符，需要二个字节编码

大部分常用字（含中文），使用三个字节编码

其他极少使用的Unicode辅助字符，使用四字节编码

字符流中和编码解码问题相关的两个类

InputStreamReader：是从字节流到字符流的桥梁

它读取字节，并使用指定的编码将其解码为字符

它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

OutputStreamWriter：是从字符流到字节流的桥梁

是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节

它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter osw = new OutputStreamWriter(new                                             FileOutputStream("myCharStream\\osw.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new                                              FileOutputStream("myCharStream\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();

        //InputStreamReader isr = new InputStreamReader(new                                              FileInputStream("myCharStream\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new                                                 FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1) {
            System.out.print((char)ch);
        }
        isr.close();
    }
}

字符缓冲流

字符缓冲流介绍

- BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

- BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
        BufferedWriter bw = new BufferedWriter(new                                                            FileWriter("myCharStream\\bw.txt"));
        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.close();

        //BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new                                                           FileReader("myCharStream\\bw.txt"));

        //一次读取一个字符数据
//        int ch;
//        while ((ch=br.read())!=-1) {
//            System.out.print((char)ch);
//        }

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1) {
            System.out.print(new String(chs,0,len));
        }

        br.close();
    }
}

字符缓冲流特有功能

方法介绍

BufferedWriter：

方法名	说明
void newLine()	写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

方法名	说明
String readLine()	读一行文字。结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

代码演示

publicclassBufferedStreamDemo02 {
    publicstaticvoidmain(String[] args) throwsIOException {

        //创建字符缓冲输出流
        BufferedWriterbw=newBufferedWriter(new                                                          FileWriter("myCharStream\\bw.txt"));

        //写数据
        for (inti=0; i<10; i++) {
            bw.write("hello"+i);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }

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

        //创建字符缓冲输入流
        BufferedReaderbr=newBufferedReader(new                                                          FileReader("myCharStream\\bw.txt"));

        Stringline;
        while ((line=br.readLine())!=null) {
            System.out.println(line);
        }

        br.close();
    }
}

文件到集合

案例需求

把ArrayList集合中的字符串数据写入到文本文件。要求：每一个字符串元素作为文件中的一行数据

实现步骤

创建ArrayList集合

往集合中存储字符串元素

创建字符缓冲输出流对象

遍历集合，得到每一个字符串数据

调用字符缓冲输出流对象的方法写数据

释放资源

代码实现

public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();

        //往集合中存储字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\array.txt"));

        //遍历集合，得到每一个字符串数据
        for(String s : array) {
            //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }

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

本少爷头发还长

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流学习小结

是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等- BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途。
复制链接

扫一扫