java基础入门-19-【IO（字节流&字符流）】-Toy模板网

这篇具有很好参考价值的文章主要介绍了java基础入门-19-【IO（字节流&字符流）】。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

28、IO（字节流&字符流）

1. IO概述

java基础入门-19-【IO（字节流&字符流）】

1.1 什么是IO

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

1.2 IO的分类

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从其他设备上读取到内存中的流。
输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。
字符流 ：以字符为单位，读写数据的流。

java基础入门-19-【IO（字节流&字符流）】

1.3 IO的流向说明图解

java基础入门-19-【IO（字节流&字符流）】

1.4 顶级父类们

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

2. 字节流

java基础入门-19-【IO（字节流&字符流）】

2.1 一切皆为字节

一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

2.2 字节输出流【OutputStream】

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
public abstract void write(int b) ：将指定的字节输出流。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.3 FileOutputStream类

java基础入门-19-【IO（字节流&字符流）】

FileOutputStream原理

java基础入门-19-【IO（字节流&字符流）】

FileOutputStream书写细则

java基础入门-19-【IO（字节流&字符流）】

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo2 {
   
    public static void main(String[] args) throws IOException {
   
        /*
            字节输出流的细节：
                    1.创建字节输出流对象
                        细节1：参数字符串表示的路径或者是File对象都是可以的
                        细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
                        细节3：如果文件已经存在，则会清空文件
                    2.写数据
                        细节：write方法的参数是整数，但是实际上写到本地文件中的整数在ASCII上对应的字符
                        97  ---> a
                        100 ---> d
                        '9'
                        '7'
                    3.释放资源
                        每次使用完流之后都要释放资源
         */

        //1.创建对象
        //FileOutputStream fos = new FileOutputStream(new File("day26-myio\\file\\c.txt"));
        FileOutputStream fos = new FileOutputStream("day26-myio\\file\\c.txt");

        //2.写出数据
        fos.write(57);
        fos.write(55);

        //3.释放资源
        fos.close();
    }
}

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。

构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {
   
    public static void main(String[] args) {
   
   	 	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo1 {
   
    public static void main(String[] args) throws IOException {
   
        /*
           演示：字节输出流FileOutputStream
           实现需求：写出一段文字到本地文件中。（暂时不写中文）

           实现步骤：
                 创建对象
                 写出数据
                 释放资源
         */

        //1.创建对象
        //写出  输出流  OutputStream
        //本地文件  File
        //FileOutputStream fos = new FileOutputStream("指定文件的路径");
        FileOutputStream fos = new FileOutputStream("day26-myio\\file\\a.txt");

        //2.写出数据
        fos.write(97);

        //3.释放资源
        fos.close();
    }
}

java基础入门-19-【IO（字节流&字符流）】

FileOutputStream写数据的3种方式

java基础入门-19-【IO（字节流&字符流）】

import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamDemo4 {
   
    public static void main(String[] args) throws IOException {
   
        /*
           void write(int b)                       一次写一个字节数据
           void write(byte[] b)                    一次写一个字节数组数据
           void write(byte[] b, int off, int len)  一次写一个字节数组的部分数据
           参数一：
                数组
           参数二：
                起始索引  0
           参数三：
                个数      3
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("day26-myio\\file\\d.txt");

        //2.写出数据
        byte[] bytes = {
   97, 98, 99, 100, 101};
        //fos.write(97);//a
        //fos.write(98);//b
        //fos.write(bytes);//abcde
        fos.write(bytes,2,3);

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

    }
}

写出字节数据

写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

public class FOSWrite {
   
    public static void main(String[] args) throws IOException {
   
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	fos.write(99); // 写出第3个字节
      	// 关闭资源
        fos.close();
    }
}
输出结果：
abc

小贴士：

虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。

流操作完毕后，必须释放系统资源，调用close方法，千万记得。

写出字节数组：write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {
   
    public static void main(String[] args) throws IOException {
   
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "黑马程序员".getBytes();
      	// 写出字节数组数据
      	fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
黑马程序员

写出指定长度字节数组：write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：

public class FOSWrite {
   
    public static void main(String[] args) throws IOException {
   
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
      	// 关闭资源
        fos.close();
    }
}
输出结果：
cd

数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

public FileOutputStream(File file, boolean append)：创建文件输出流以写入由指定的 File对象表示的文件。
public FileOutputStream(String name, boolean append)：创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
   
    public static void main(String[] args) throws IOException {
   
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
      	// 字符串转换为字节数组
      	byte[] b = "abcde".getBytes();
		// 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
      	// 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde

写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {
   
    public static void main(String[] args) throws IOException {
   
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
      	// 定义字节数组
      	byte[] words = {
   97,98,99,100,101};
      	// 遍历数组
        for (int i = 0; i < words.length; i++) {
   
          	// 写出一个字节
            fos.write(words[i]);
          	// 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
      	// 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e

回车符\r和换行符\n ：

回车符：回到一行的开头（return）。

换行符：下一行（newline）。

系统中的换行：

Windows系统里，每行结尾是 回车+换行 ，即\r\n；

Unix系统里，每行结尾只有 换行 ，即\n；

Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

换行和续写

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteStreamDemo5 {
   
    public static void main(String[] args) throws IOException {
   
        /*
            换行写：
                再次写出一个换行符就可以了
                windows: \r\n
                Linux:   \n
                Mac:     \r
            细节：
                在windows操作系统当中，java对回车换行进行了优化。
                虽然完整的是\r\n，但是我们写其中一个\r或者\n,
                java也可以实现换行，因为java在底层会补全。
            建议：
                不要省略，还是写全了。

            续写：
                如果想要续写，打开续写开关即可
                开关位置：创建对象的第二个参数
                默认false：表示关闭续写，此时创建对象会清空文件
                手动传递true：表示打开续写，此时创建对象不会清空文件
         */

        //1.创建对象
        FileOutputStream fos = new FileOutputStream("day26-myio\\file\\e.txt", true);

        //2.写出数据
        //libai
        String str1 = "6666\r\n";
        byte[] bytes1 = str1.getBytes();
        System.out.println(Arrays.toString(bytes1));
        fos.write(bytes1);

        //再次写出一个换行符就可以了
        String wrap = "\r\n";
        byte[] bytes3 = wrap.getBytes();
        System.out.println(Arrays.toString(bytes3));
        fos.write(bytes3);

        String str2 = "libai";
        byte[] bytes2 = str2.getBytes();
        System.out.println(Arrays.toString(bytes2));
        fos.write(bytes2);

        //3.释放资源
        fos.close();
    }
}

java基础入门-19-【IO（字节流&字符流）】

总结

java基础入门-19-【IO（字节流&字符流）】

2.4 字节输入流【InputStream】

java基础入门-19-【IO（字节流&字符流）】

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read()：从输入流读取数据的下一个字节。
public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组 b中。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

2.5 FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

java基础入门-19-【IO（字节流&字符流）】

字节输入流FileInputStream的基本用法

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ByteFileInputStreamDemo1 {
   
    public static void main(String[] args) throws IOException {
   
        /*
         * 演示：字节输入流FileInputStream
         * 实现需求：读取文件中的数据。（暂时不写中文）
         *
         * 实现步骤：
         *       创建对象
         *       读取数据
         *       释放资源
         * */

        //1.创建对象
        FileInputStream fis = new FileInputStream("day26-myio\\file\\d.txt");

        //2.读取数据
        int b1 = fis.read();
        System.out.println("b1 = " + b1);
        System.out.println("b1 = " + (char) b1);

        int b2 = fis.read();
        System.out.println("b2 = " + (char) b2);

        int b3 = fis.read();
        System.out.println("b3 = " + (char) b3);
        
        int b4 = fis.read();
        System.out.println("b4 = " + b4);

        //3.释放资源
        fis.close();
    }
}

java基础入门-19-【IO（字节流&字符流）】

FileInputStream的书写细节

java基础入门-19-【IO（字节流&字符流）】文章来源地址https://www.toymoban.com/news/detail-470047.html

FileInputStream的循环读取

import java.io.FileInputStream;
import java.io.IOException;

public class ByteFileInputStreamDemo3 {
   
    public static void main(String[] args) throws IOException {
   
        /*
            字节输入流循环读取
                read :表示读取数据，而且是读取一个数据就移动一次指针
         */

        //1.创建对象
        FileInputStream fis = new FileInputStream("day26-myio\\file\\f.txt"