字节流，字符流（java）

IO概述

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

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

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

IO的分类

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

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

根据数据类型分为：字节流和字符流

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

字节流

  • 一切皆为字节：一切文件数据（文本，图像，视频等）在存储时，都是以二进制形式保存的，都是一个一个的字节，在传输时一样如此。所以，字节流可以传输任意文件数据。在操作流时，无论使用什么对象，底层的数据始终为二进制数据

字节输出流：

  • java.io.OutputStraem抽象类是代表字节输出流的所有类的超类，将指定的字节信息写出到目的地。定义了字节输出流的基本共性方法
    • 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方法，当完成流的操作，必须调用此方法，释放系统资源

FileOutputStream

OutputStream有很多子类，java.io.FileOutputStream类是文件输出流，用于将数据写到文件

构造方法

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

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

  • 构造举例，代码如下：

    package demo.stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileOutputStramContractor {
    public static void main(String[] args) throws FileNotFoundException {
        //使用flie对象创建流对象
        FileOutputStream fileOutputStream = new FileOutputStream(new File("a.txt"));
        System.out.println(fileOutputStream);
        //使用文件名创建流对象
        FileOutputStream outputStream = new FileOutputStream("b.txt");
        System.out.println(outputStream);
    }
}

写出字节数据

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

    package demo.stream;

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

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt");
        //写数据
        fileOutputStream.write(67);
        fileOutputStream.write(89);
        fileOutputStream.write(34);
        fileOutputStream.close();
    }
}

    注意：

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

    流操作完毕，必须释放系统资源，调用close方法

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

    package demo.stream;

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

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt");
        //将字符数组写入流
        byte[] bytes = "hello，mps！".getBytes();
        fileOutputStream.write(bytes);
        fileOutputStream.close();
    }
}

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

    package demo.stream;

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

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt");
        //将字符数组写入流
        byte[] bytes = "hello,mps！".getBytes();
        fileOutputStream.write(bytes,2,3);
        fileOutputStream.close();
    }
}

数据追加续写

在上面的例子中，每次程序运行，创建流对象，都回清空目标文件中的数据，接下来我们将会保留目标文件中的数据

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

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

package demo.stream;

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

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt",true);
        //将字符数组写入流
        byte[] bytes = " hello,mps！".getBytes();
        fileOutputStream.write(bytes);
        fileOutputStream.close();
    }
}

写出换行

windows系统中，换行符号是\r\n。把以指定是否追加续写的内容换行，代码演示：

package demo.stream;

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

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileOutputStream fileOutputStream = new FileOutputStream("fos.txt");
        //定义字符数组
        byte[] bytes = {96,97,98,99};
        for (int i = 0; i < bytes.length; i++) {
            fileOutputStream.write(bytes[i]);
            fileOutputStream.write("\r\n".getBytes());
        }
        fileOutputStream.close();
    }
}
  • 回车符\r和换行符\n
    • 回车符：回到一行的开头（return）
    • 换行符：下一行（newline）
  • 系统中的换行：
    • windows系统里，每行结尾是回车+换行,即\r\n
    • unix系统里，每行结尾只有换行，即\n
    • mac系统里，每行结尾是回车，即\r。

字节数入流

FileInputStream类

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

构造方法

  • FileInputStream(File file):通过打开实体文件的链接来创建一个FileInputStream，该文件由文件系统中的File对象file命名
  • FileInputStream(String name):通过打开与实际文件的链接来创建一个FileOutputStream，该文件由文件系统中的路径名称name命名

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件，会抛出FileNotFoundException

  • 构造举例，如下面
package demo.stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class FileInputStreamConstructor {
    public static void main(String[] args) throws FileNotFoundException {
        //根据file对象创建流对象
        FileInputStream fileOutputStream = new FileInputStream(new File("a.txt"));
        //通过文件名创建流对象
        FileInputStream fileInputStream = new FileInputStream("b.txt");
    }
}

读取字节数据

  • 读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读到文件末尾，返回-1，代码演示：
package demo.stream;

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

public class FISRead {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("a.txt");
        int read = fileInputStream.read();
        System.out.println((char) read);
        read = fileInputStream.read();
        System.out.println((char) read);
        read = fileInputStream.read();
        System.out.println((char) read);
        read = fileInputStream.read();
        System.out.println(read);
    }
}
  • 循环改进读取方式，代码使用演示:
package demo.stream;

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

public class FISRead {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("a.txt");
        int read;
        while ((read = fileInputStream.read())!=-1) {
            System.out.println((char) read);
        }
        fileInputStream.close();
    }
}
  • 虽然读取了一个字节，但是会子动提升为int类型
  • 流操作完成后，必须释放系统资源，调用close方法
  • 使用字节数组读取：read（byte[] b）,每次读取b的长度的字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1，代码如下：
package demo.stream;

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

public class FISRead {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("a.txt");
        int read;
        byte[] bytes = new byte[2];
        while ((read = fileInputStream.read(bytes))!=-1) {
            System.out.println(new String(bytes));
        }
        fileInputStream.close();
    }
}

错误数据，是由于最后一次读取时，只读取一个字节，数组中，上次读取的数据没有被完全替换，所以要获取有效的字节，代码使用演示：

package demo.stream;

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

public class FISRead {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("a.txt");
        int read;
        byte[] bytes = new byte[2];
        while ((read = fileInputStream.read(bytes))!=-1) {
            System.out.println(new String(bytes,0,read));
        }
        fileInputStream.close();
    }
}

注意：

使用数组读取时，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率

字节流练习：图片复制

package demo.stream;

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

public class Copy {
    public static void main(String[] args) throws IOException {
        //创建流对象，指定数据源
        FileInputStream fileInputStream = new FileInputStream("1.jpeg");
        //指定目的地
        FileOutputStream fileOutputStream = new FileOutputStream("test.jpeg");
        //读写数据，定义字符数组
        byte[] bytes = new byte[1024];
        //定义长度
        int len;
        //循环读取
        while((len = fileInputStream.read(bytes))!= -1){
            //写数据
            fileOutputStream.write(bytes,0,len);
        }
        //关闭资源
        fileInputStream.close();
        fileOutputStream.close();
    }
}

流的关闭原则：先开后关，后开先关

字符流

当使用字节流读取文本时，会有问题，读到中文字符时，可能不会显示完整字符，是因为一个中文字符可能占用多个字节存储。所以java提供了一些字符流类，以字符单位来读写数据，专门用来处理文本文件

字符数入流

java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。定义了文字数入流的基本共性功能方法。

  • public void close():关闭此流并释放此流关联的任何系统资源
  • public int read():从输入流读取一个字符
  • public int read(char[] buf):从输入流读取一些字符，并把它们存储到字符数组cbuf中

FileReader类

java.io.FileReader类是读取字符文件的遍历类。构造时使用系统默认的字符编码和默认字节缓冲区。

字符编码：字节与字符的对应规则。windows系统的中文编码默认是GBK编码表

字节缓冲区：一个字节数组，用来临时存储字节数据

构造方法

  • FileReader(File file):创建一个新的FileReader，给定要读取的File对象
  • FileReader(String fileName):创建一个新的FileReader，给定要读取的文件的名称

当创建一个流对象时，必须传入一个新的文件路径。类似FileInputStream

  • 构造举例，代码如下：
package demo.stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class FileReaderConstructor {
    public static void main(String[] args) throws FileNotFoundException {
        //使用file对象创建流对象
        FileReader fileReader = new FileReader(new File("a.txt"));
        //使用文件名创建流对象
        FileReader fileReader1 = new FileReader("a.txt");
    }
}

读取字符数据

  • 读取字符：read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用如下：
package demo.stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderConstructor {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileReader fileReader = new FileReader("a.txt");
        int b;
        //循环读取
        while ((b=fileReader.read())!=-1){
            System.out.println((char)b);
        }
    }
}

虽然提取了一个字符，但是会自动提升为int类型。

  • 使用字符数组读取：read(char[] cbuf)，每次读取数组长度个字符长度到数组中，返回读取到的有效字符个数，读取到末尾，返回-1，代码如下：
package demo.stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderConstructor {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileReader fileReader = new FileReader("a.txt");
        int b;
        //定义一个字符数组，作为装字符的容器
        char[] chars = new char[2];
        //循环读取
        while ((b=fileReader.read(chars))!=-1){
            System.out.println(new String(chars));
        }
        fileReader.close();
    }
}

获取有效字符改进，代码如下：

package demo.stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderConstructor {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileReader fileReader = new FileReader("a.txt");
        int b;
        //定义一个字符数组，作为装字符的容器
        char[] chars = new char[2];
        //循环读取
        while ((b=fileReader.read(chars))!=-1){
            System.out.println(new String(chars,0,b));
        }
        fileReader.close();
    }
}

字符输出流

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

  • void write(int c)：写入单个字符
  • void write(char[] cbuf)：写入字符数组
  • abstract void write(char[] cbuf,int off,int len)：写入字符数组的某一部分，off数组的开始索引，len写的字符个数
  • void write(String str)：写入字符串
  • void write(String str,int off, int len)：写入字符串的某一部分，off字符串的开始索引，len写的字符个数
  • void flush刷新该流的缓冲
  • void close()关闭此流，但要先刷新它。

FileWrite类

java.io.FileWriter类是写出字符到文件的类。构造时使用系统默认的字符编码和默认的字节缓冲区

构造方法

  • FileWriter(File file)：创建一个新的FileWriter，给定要读取的File对象
  • FileWriter(String fileName)：创建一个新的FileWriter，给定要读取的文件的名称。

当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。

  • 构造举例，代码如下：
package demo.stream;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriterConstructor {
    public static void main(String[] args) throws IOException {
        //使用File创建流对象
        FileWriter fileWriter = new FileWriter(new File("a.txt"));
        //使用文件名创建流对象
        FileWriter writer = new FileWriter("b.txt");
        
    }
}

基本写出数据

  • 写出字符：write(int b)方法，可以每次写出一个字符数据，代码演示：
package demo.stream;

import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileWriter fileWriter = new FileWriter("b.txt");
        //写出数据
        fileWriter.write(97);
        fileWriter.write('c');
        fileWriter.write('d');
        fileWriter.write(30000);
        /*
        【注意】关闭资源时,与FileOutputStream不同。
        如果不关闭,数据只是保存到缓冲区，并未保存到文件。
         */
        fileWriter.close();
    }
}

注意：

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

未调用close方法，数据只是保存到了缓冲区，并未写到文件中。

关闭和刷新

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush方法了。

  • flush：刷新缓冲区，流对象可以继续使用
  • close：先刷新缓冲区，然后通知系统释放资源。流对象不能再被使用了。

代码：

package demo.stream;

import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileWriter fileWriter = new FileWriter("b.txt");
        //写出数据,通过flush
       fileWriter.write("hello ");
       fileWriter.flush();
       fileWriter.write("world");

       //写数据，通过close
        fileWriter.write(" hero");
       fileWriter.close();
       fileWriter.write("mps"); //报错java.io.IOException: Stream closed
//       fileWriter.close();
        /*
        【注意】关闭资源时,与FileOutputStream不同。
        如果不关闭,数据只是保存到缓冲区，并未保存到文件。
         */
        fileWriter.close();
    }
}

即使使用flush方法写出了数据，操作的最后还是要调用close方法，释放系统资源

写出其他数据

  • 写出字符数组：write(char[] cbuf)和write(char[] cbuf,int off,int len),每次可以写出字符数组中的数据，用法类似FileOutputStream，代码：
package demo.stream;

import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileWriter fileWriter = new FileWriter("b.txt");
        //写出数据
        char[] chars = "hello，mps".toCharArray();
        fileWriter.write(chars,6,3);
        fileWriter.close();
    }
}
  • 写出字符串：write(String str)和Write(String str,int off,int len),每次可以写出字符串中的数据，更为方便，代码：
package demo.stream;

import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileWriter fileWriter = new FileWriter("b.txt");
        //写出数据
        String msg = "hello，mps";
        fileWriter.write(msg);
        fileWriter.close();
    }
}
  • 续写和换行：类似FileOutputStream
package demo.stream;

import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) throws IOException {
        //使用文件名创建流对象
        FileWriter fileWriter = new FileWriter("b.txt",true);
        //写出数据
        fileWriter.write("hello，");
        fileWriter.write("\r\n");
        fileWriter.write("mps");
        fileWriter.close();
    }
}

字符流，只能操作文本文件，不能操作图片，视频等非文本文件

当我们单纯读或者写文本文件时，使用字符流，其他使用字节流。

属性集

java.util.Properties继承于Hashtable,来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多java类使用，比如获取系统属性时，System.getProperties方法就是返回一个Properties对象。

Properties类

构造方法

  • public Properties():创建一个空的属性列表。
  • 基本的存储方法
    • public Object setProperty(String key, String value):保存一对属性
    • public String getProperties(String key):使用此属性列表中指定的键搜索属性值
    • public Set<String> stringPropertyNames():所有键的名称的集合
package demo.stream;

import java.util.Properties;
import java.util.Set;

public class ProDemo {
    public static void main(String[] args) {
        //创建属性集
        Properties properties = new Properties();
        //设置属性集
        properties.setProperty("filename","a.txt");
        properties.setProperty("length","12345");
        properties.setProperty("location","/user/hero");

        //打印属性集对象
        System.out.println(properties);
        //通过键获取值
        System.out.println(properties.getProperty("filename"));
        System.out.println(properties.getProperty("length"));
        System.out.println(properties.getProperty("location"));
        //遍历集合，获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string+":"+properties.getProperty(string));
        }
    }
}

与流相关的方法

  • public void load(InputStream inStream):从字节数入流中读取键值对

    参数中使用了字节数入流，通过流对象，可以关联到某文件上，能够加载文本中的数据了。文本数据格式：

    location=/user/hero
filename=a.txt
length=12345

代码演示：

package demo.stream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class ProDemo {
    public static void main(String[] args) throws IOException {
        //创建属性集
        Properties properties = new Properties();
        //加载文本中的数据
        properties.load(new FileInputStream("b.txt"));
        //遍历集合，获取所有键的集合
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string+":"+properties.getProperty(string));
        }
    }
}

注意：

文本中的数据，必须是键值对形式，可以使用空格，等号，冒号等符号分隔。

版权声明：本文为heromps原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。