天道酬勤,学无止境

最详细的Java知识点--字节流、字符流

字节流、字符流

主要内容

  • IO流
  • 字节流
  • 字符流
  • 异常处理
  • Properties

目标

  • 能够说出IO流的分类和功能
  • 能够使用字节输出流写出数据到文件
  • 能够使用字节输入流读取数据到程序
  • 能够理解读取数据read(byte[])方法的原理
  • 能够使用字节流完成文件的复制
  • 能够使用FileWirter写数据到文件
  • 能够说出FileWriter中关闭和刷新方法的区别
  • 能够使用FileWriter写数据的5个方法
  • 能够使用FileWriter写数据实现换行和追加写
  • 能够使用FileReader读数据
  • 能够使用FileReader读数据一次一个字符数组
  • 能够使用Properties的load方法加载文件中配置信息

第一章 IO概述

1.1 什么是IO

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

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

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

1.2 IO的分类

根据数据的流向分为:输入流输出流

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

格局数据的类型分为:字节流字符流

  • 字节流 :以字节为单位,读写数据的流。
  • 字符流 :以字符为单位,读写数据的流。

1.3 IO的流向说明图解

在这里插入图片描述

1.4 顶级父类们


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

第二章 字节流

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类

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");}}

写出字节数据

  1. 写出字节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

小贴士:

  1. 虽然参数为int类型四个字节,但是只会保留一个字节的信息写出。
  2. 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
  1. 写出字节数组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();}}输出结果:
我是程序员

  1. 写出指定长度字节数组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统一。

2.4 字节输入流【InputStream】

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

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

小贴士:

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

2.5 FileInputStream类

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

构造方法

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

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

  • 构造举例,代码如下:
public class FileInputStreamConstructor throws IOException{public static void main(String[] args) {
   	 	// 使用File对象创建流对象File file = new File("a.txt");FileInputStream fos = new FileInputStream(file);  // 使用文件名称创建流对象FileInputStream fos = new FileInputStream("b.txt");}}

读取字节数据

  1. 读取字节read方法,每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回-1,代码使用演示:
public class FISRead {public static void main(String[] args) throws IOException{  	// 使用文件名称创建流对象   	FileInputStream fis = new FileInputStream("read.txt");  	// 读取数据,返回一个字节int read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);read = fis.read();System.out.println((char) read);  	// 读取到末尾,返回-1   	read = fis.read();System.out.println( read);// 关闭资源fis.close();}}输出结果:
a
b
c
d
e-1

循环改进读取方式,代码使用演示:

public class FISRead {public static void main(String[] args) throws IOException{  	// 使用文件名称创建流对象   	FileInputStream fis = new FileInputStream("read.txt");  	// 定义变量,保存数据int b ;// 循环读取while ((b = fis.read())!=-1) {System.out.println((char)b);}// 关闭资源fis.close();}}输出结果:
a
b
c
d
e

小贴士:

  1. 虽然读取了一个字节,但是会自动提升为int类型。
  2. 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
  1. 使用字节数组读取read(byte[] b),每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1 ,代码使用演示:
public class FISRead {public static void main(String[] args) throws IOException{  	// 使用文件名称创建流对象.   	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde  	// 定义变量,作为有效个数int len ;// 定义字节数组,作为装字节数据的容器   byte[] b = new byte[2];// 循环读取while (( len= fis.read(b))!=-1) {   	// 每次读取后,把数组变成字符串打印System.out.println(new String(b));}// 关闭资源fis.close();}}输出结果:
ab
cd
ed

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

public class FISRead {public static void main(String[] args) throws IOException{  	// 使用文件名称创建流对象.   	FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde  	// 定义变量,作为有效个数int len ;// 定义字节数组,作为装字节数据的容器   byte[] b = new byte[2];// 循环读取while (( len= fis.read(b))!=-1) {   	// 每次读取后,把数组的有效字节部分,变成字符串打印System.out.println(new String(b,0,len));//  len 每次读取的有效字节个数}// 关闭资源fis.close();}}输出结果:
ab
cd
e

小贴士:

使用数组读取,每次读取多个字节,减少了系统间的IO操作次数,从而提高了读写的效率,建议开发中使用。

2.6 字节流练习:图片复制

复制原理图解

在这里插入图片描述

案例实现

复制图片文件,代码使用演示:

public class Copy {public static void main(String[] args) throws IOException {// 1.创建流对象// 1.1 指定数据源FileInputStream fis = new FileInputStream("D:\\test.jpg");// 1.2 指定目的地FileOutputStream fos = new FileOutputStream("test_copy.jpg");// 2.读写数据// 2.1 定义数组byte[] b = new byte[1024];// 2.2 定义长度int len;// 2.3 循环读取while ((len = fis.read(b))!=-1) {// 2.4 写出数据fos.write(b, 0 , len);}// 3.关闭资源fos.close();fis.close();}}

小贴士:

流的关闭原则:先开后关,后开先关。

第三章 字符流

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

3.1 字符输入流【Reader】

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

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

3.2 FileReader类

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

小贴士:

  1. 字符编码:字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。

    idea中UTF-8

  2. 字节缓冲区:一个字节数组,用来临时存储字节数据。

构造方法

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

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

  • 构造举例,代码如下:
public class FileReaderConstructor throws IOException{public static void main(String[] args) {
   	 	// 使用File对象创建流对象File file = new File("a.txt");FileReader fr = new FileReader(file);  // 使用文件名称创建流对象FileReader fr = new FileReader("b.txt");}}

读取字符数据

  1. 读取字符read方法,每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回-1,循环读取,代码使用演示:
public class FRRead {public static void main(String[] args) throws IOException {  	// 使用文件名称创建流对象   	FileReader fr = new FileReader("read.txt");  	// 定义变量,保存数据int b ;// 循环读取while ((b = fr.read())!=-1) {System.out.println((char)b);}// 关闭资源fr.close();}}输出结果:
我
是
程
序
员

小贴士:虽然读取了一个字符,但是会自动提升为int类型。

  1. 使用字符数组读取read(char[] cbuf),每次读取b的长度个字符到数组中,返回读取到的有效字符个数,读取到末尾时,返回-1 ,代码使用演示:
public class FRRead {public static void main(String[] args) throws IOException {  	// 使用文件名称创建流对象   	FileReader fr = new FileReader("read.txt");  	// 定义变量,保存有效字符个数int len ;// 定义字符数组,作为装字符数据的容器 char[] cbuf = new char[2];// 循环读取while ((len = fr.read(cbuf))!=-1) {System.out.println(new String(cbuf));}// 关闭资源fr.close();}}输出结果:
我是
程序
员序

获取有效的字符改进,代码使用演示:

public class FISRead {public static void main(String[] args) throws IOException {  	// 使用文件名称创建流对象   	FileReader fr = new FileReader("read.txt");  	// 定义变量,保存有效字符个数int len ;// 定义字符数组,作为装字符数据的容器char[] cbuf = new char[2];// 循环读取while ((len = fr.read(cbuf))!=-1) {System.out.println(new String(cbuf,0,len));}// 关闭资源fr.close();}}输出结果:
黑马
程序
员

3.3 字符输出流【Writer】

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

  • 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() 关闭此流,但要先刷新它。

3.4 FileWriter类

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

构造方法

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

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

  • 构造举例,代码如下:
public class FileWriterConstructor {public static void main(String[] args) throws IOException {
   	 	// 使用File对象创建流对象File file = new File("a.txt");FileWriter fw = new FileWriter(file);  // 使用文件名称创建流对象FileWriter fw = new FileWriter("b.txt");}}

基本写出数据

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

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     
      	// 写出数据  	fw.write(97); // 写出第1个字符  	fw.write('b'); // 写出第2个字符  	fw.write('C'); // 写出第3个字符  	fw.write(30000); // 写出第4个字符,中文编码表中30000对应一个汉字。  
      	/*
        【注意】关闭资源时,与FileOutputStream不同。
      	 如果不关闭,数据只是保存到缓冲区,并未保存到文件。
        */// fw.close();}}输出结果:
abC田

小贴士:

  1. 虽然参数为int类型四个字节,但是只会保留一个字符的信息写出。
  2. 未调用close方法,数据只是保存到了缓冲区,并未写出到文件中。

关闭和刷新

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

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

代码使用演示:

public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");// 写出数据,通过flushfw.write('刷'); // 写出第1个字符fw.flush();fw.write('新'); // 继续写出第2个字符,写出成功fw.flush();  
      	// 写出数据,通过closefw.write('关'); // 写出第1个字符fw.close();fw.write('闭'); // 继续写出第2个字符,【报错】java.io.IOException: Stream closedfw.close();}}

小贴士:即便是flush方法写出了数据,操作的最后还是要调用close方法,释放系统资源。

写出其他数据

  1. 写出字符数组write(char[] cbuf)write(char[] cbuf, int off, int len) ,每次可以写出字符数组中的数据,用法类似FileOutputStream,代码使用演示:
public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串转换为字节数组  	char[] chars = "我是程序员".toCharArray();  
      	// 写出字符数组  	fw.write(chars); // 我是程序员// 写出从索引2开始,2个字节。索引2是'程',两个字节,也就是'程序'。fw.write(b,2,2); // 程序  
      	// 关闭资源fos.close();}}

  1. 写出字符串write(String str)write(String str, int off, int len) ,每次可以写出字符串中的数据,更为方便,代码使用演示:
public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象FileWriter fw = new FileWriter("fw.txt");     
      	// 字符串  	String msg = "我是程序员";  
      	// 写出字符数组  	fw.write(msg); //我是程序员  
		// 写出从索引2开始,2个字节。索引2是'程',两个字节,也就是'程序'。fw.write(msg,2,2);// 程序  // 关闭资源fos.close();}}

  1. 续写和换行:操作类似于FileOutputStream。
public class FWWrite {public static void main(String[] args) throws IOException {// 使用文件名称创建流对象,可以续写数据FileWriter fw = new FileWriter("fw.txt",true);     
      	// 写出字符串fw.write("我是");  	// 写出换行  	fw.write("\r\n");  	// 写出字符串
  		fw.write("程序员");  	// 关闭资源fw.close();}}输出结果:我是
程序员

小贴士:字符流,只能操作文本文件,不能操作图片,视频等非文本文件。

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

第四章 IO异常的处理

JDK7前处理

之前的入门练习,我们一直把异常抛出,而实际开发中并不能这样处理,建议使用try...catch...finally 代码块,处理异常部分,代码使用演示:

public class HandleException1 {public static void main(String[] args) {  	// 声明变量FileWriter fw = null;try {//创建流对象fw = new FileWriter("fw.txt");// 写出数据fw.write("我是程序员"); //我是程序员} catch (IOException e) {e.printStackTrace();} finally {try {if (fw != null) {fw.close();}} catch (IOException e) {e.printStackTrace();}}}}

JDK7的处理(扩展知识点了解内容)

还可以使用JDK7优化后的try-with-resource 语句,该语句确保了每个资源在语句结束时关闭。所谓的资源(resource)是指在程序完成后,必须关闭的对象。

格式:

try (创建流对象语句,如果多个,使用';'隔开) {// 读写数据} catch (IOException e) {
	e.printStackTrace();}

代码使用演示:

public class HandleException2 {public static void main(String[] args) {  	// 创建流对象try ( FileWriter fw = new FileWriter("fw.txt"); ) {// 写出数据fw.write("我是程序员"); //我是程序员} catch (IOException e) {e.printStackTrace();}}}

JDK9的改进(扩展知识点了解内容)

JDK9中try-with-resource 的改进,对于引入对象的方式,支持的更加简洁。被引入的对象,同样可以自动关闭,无需手动close,我们来了解一下格式。

改进前格式:

// 被final修饰的对象final Resource resource1 = new Resource("resource1");// 普通对象Resource resource2 = new Resource("resource2");// 引入方式:创建新的变量保存try (Resource r1 = resource1; Resource r2 = resource2) { // 使用对象}

改进后格式:

// 被final修饰的对象final Resource resource1 = new Resource("resource1");// 普通对象Resource resource2 = new Resource("resource2");// 引入方式:直接引入try (resource1; resource2) { // 使用对象}

改进后,代码使用演示:

public class TryDemo {public static void main(String[] args) throws IOException {   	// 创建流对象final  FileReader fr  = new FileReader("in.txt");FileWriter fw = new FileWriter("out.txt");   	// 引入到try中try (fr; fw) {  	// 定义变量int b;  	// 读取数据  	while ((b = fr.read())!=-1) {// 写出数据	fw.write(b);  	}} catch (IOException e) {e.printStackTrace();}}}

第五章 属性集

5.1 概述

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

5.2 Properties类

构造方法

  • public Properties() :创建一个空的属性列表。

基本的存储方法

  • public Object setProperty(String key, String value) : 保存一对属性。
  • public String getProperty(String key) :使用此属性列表中指定的键搜索属性值。
  • public Set<String> stringPropertyNames() :所有键的名称的集合。
public class ProDemo {public static void main(String[] args) throws FileNotFoundException {// 创建属性集对象Properties properties = new Properties();// 添加键值对元素properties.setProperty("filename", "a.txt");properties.setProperty("length", "209385038");properties.setProperty("location", "D:\\a.txt");// 打印属性集对象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 key : strings ) {  	System.out.println(key+" -- "+properties.getProperty(key));}}}输出结果:{filename=a.txt, length=209385038, location=D:\a.txt}a.txt209385038D:\a.txt
filename -- a.txt
length -- 209385038location -- D:\a.txt

与流相关的方法

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

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

filename=a.txt
length=209385038
location=D:\a.txt

加载代码演示:

public class ProDemo2 {public static void main(String[] args) throws FileNotFoundException {// 创建属性集对象Properties pro = new Properties();// 加载文本中信息到属性集pro.load(new FileInputStream("read.txt"));// 遍历集合并打印Set<String> strings = pro.stringPropertyNames();for (String key : strings ) {  	System.out.println(key+" -- "+pro.getProperty(key));} }}输出结果:
filename -- a.txt
length -- 209385038location -- D:\a.txt

小贴士:文本中的数据,必须是键值对形式,可以使用空格、等号、冒号等符号分隔。

标签

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 【Java基础-3】吃透Java IO:字节流、字符流、缓冲流
    Java IO流 前言1 初识Java IO1.1 IO流分类1.2 案例实操 2 IO流对象2.1 File类2.2 字节流2.3 字符流2.4 序列化 3 IO流方法3.1 字节流方法3.2 字符流方法 4 附加内容4.1 位、字节、字符4.2 IO流效率对比4.3 NIO 前言 有人曾问fastjson的作者(阿里技术专家高铁):“你开发fastjson,没得到什么好处,反而挨了骂背了锅,这种事情你为什么要做呢?” 高铁答道:“因为热爱本身,就是奖励啊!” 这个回答顿时触动了我。想想自己,又何尝不是如此。写作是个痛苦的过程,用心写作就更加煎熬,需字字斟酌,反复删改才有所成。然而,当一篇篇精良文章出自己手而呈现眼前时,那些痛苦煎熬就都那么值得。如果这些博文能有幸得大家阅读和认可,就更加是莫大的鼓舞了。技术人的快乐就是可以这么纯粹和简单。 点波关注不迷路,一键三连好运连连! IO流是Java中的一个重要构成部分,也是我们经常打交道的。这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!) 下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握得很好,可以立即关闭文章。反之,你可以在后面得文章中寻找答案。 Java IO流有什么特点?Java IO流分为几种类型?字节流和字符流的关系与区别?字符流是否使用了缓冲?缓冲流的效率一定高吗?为什么
  • Java IO——字节流和字符流详解&区别对比
    Java IO——字节流和字符流详解&区别对比 概述 大多数应用程序都需要实现与设备之间的数据传输,在Java中,将这种通过不同输入输出设备(例如:输入设备、内存、显示器、网络等)之间的数据传输抽象的表述为“流”,程序允许通过流的方式与输入输出设备进行数据传输。Java中的“流”都位于Java.io包中,称之为IO(输入输出)流。 IO流,即InputOutput的缩写。 Java IO库有两个支系: 面向字节流的InputStream和OutputStream面向字符的Reader和Writer java流在处理上分为字符流和字节流。实际上字节流的InputStream和OutputStream是一切的基础。实际总线中流动的只有字节流。需要对字节流做特殊解码才能得到字符流。Java中负责从字节流向字符流解码的桥梁是:InputStreamReader和InputStreamWriter。 字节流&字符流 大多数情况下,字节是数据最小的基本单位,1 byte = 8 bit,而 1 char = 2 byte = 16 bit。 流 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。 Java中的流是对字节序列的抽象
  • Java基础---IO(一)---IO流概述、字符流、字节流、流操作规律
    第一讲 IO概述 概述 1、IO流:即InputOutput的缩写。 2、特点: 1)IO流用来处理设备间的数据传输。 2)Java对数据的操作是通过流的方式。 3)Java用于操作流的对象都在IO包中。 4)流按操作数据分为两种:字节流和字符流。 5)流按流向分为:输入流和输出流。 注意:流只能操作数据,而不能操作文件。 3、IO流的常用基类: 1)字节流的抽象基流:InputStream和OutputStream 2)字符流的抽象基流:Reader和Writer 注:此四个类派生出来的子类名称都是以父类名作为子类名的后缀,以前缀为其功能;如InputStream子类FileInputStream;Reader子类FileReader 第二讲 字符流 一、简述 1、字符流中的对象融合了编码表。使用的是默认的编码,即当前系统的编码。 2、字符流只用于处理文字数据,而字节流可以处理媒体数据。 3、既然IO流是用于操作数据的,那么数据的最常见体现形式是文件。查看API,找到一个专门用于操作文件的Writer子类对象:FileWriter。 后缀是父类名。前缀名是流对象的功能。该流对象一被初始化,就必须有被操作的文件存在。 二、字符流的读写 1、写入字符流步骤 a、创建一个FileWriter对象,该对象一被初始化,就必须要明确被操作的文件。且该目录下如果已有同名文件,则同名文件将被覆盖
  • 技术问答-12 java字节流和字符流
    1.什么是流Java中,把所有的输入和输出都当做流来处理。“流”是一种抽象概念,他代表任何有能力产出数据的数据源对象或者有能力接收数据的接收端对象。“流”屏蔽了实际的输入/输出设备中处理数据的细节。一个程序可以打开一个数据源上的流,然后按顺序读取这个流中的数据到程序中,这样的流称为输入流。一个程序打开一个目的地的流,然后按顺序的把程序中的数据写入到这个目的地中,这样的流称为输出流。2.字节流Java中的字节流处理的最基本单位是字节,他通常用来处理二进制数据。Java中最基本的两个字节流是InputStream OutputStream ,他们分别代表了一组基本的输入字节流和输出字节流。InputStream 和 OutputStream 是抽象类,实际使用中我们会用到他们的一系列子类例子:InputStream public abstract int read() throws IOException; 这个方法是从字节流中读取一个字节若到了末尾返回-1 ,他会一直阻塞直到返回一个读取到的字节或者是-1,字节流默认情况下不支持缓存,也就是每一次read调用都会请求操作系统来读取一个字节,这会伴随一次磁盘IO操作read(byte b[]) 这个方法只是在内部循环调用了read方法 关于磁盘IO操作并没有减轻 如果我们想减少磁盘IO操作,也就是使用内存缓冲
  • Java字节流与字符流及文件操作
    目录 Java.io知识点梳理File类字节流OutputStream字节流InputStream字符流Writer字符流Reader字节流与字符流的转换(了解)字节流与字符流的区别?两者如何使用? Java.io知识点梳理 如果要进行所有的文件以及文件内容的开发操作,应该使用java.io包完成,而在java.io包里面一共有五个核心类和一个核心接口: 五个核心类:File、InputStream、OutputStream、Reader、Writer一个核心接口:Serializable File类 在整个java.io包里面,File类是唯一一个与文件本身操作有关的类 ,但是不涉及到文件的具体内容,所谓的文件本身,指的是文件的创建和删除等。 几个重点掌握方法: 1.构造方法:public File(String pathname) 设置文件路径 2.普通方法:public boolean delete(); 删除文件 3.普通方法:public boolean exists()判断文件是否存在 4.普通方法:public File getParentFile();public String getParentFile();得找到父路径 5.普通方法:public Boolean mkdirs() 创建多级子目录 6普通方法:.public long length()
  • 莫逸风CSDN文章目录
    『Ⅱ』-----随笔 莫逸风CSDN文章目录 The Programmer’s Oath程序员的誓言—… 今天突发奇想写了一个小工具,CSDN文章目录生成器 vue去掉一些烦人的校验规则 输入npm install 报错node-sass@4.13… idea操作maven时控制台中文显示乱码/maven项目启… jquery validate 如何校验多个相同name IDEA debug启动的时候需要等半个小时甚至更长时间 再也不用担心了,微软官方系统(win10为例)U盘安装教程 mysql ORDER BY 中文出现错误问题 MyBatis like报错 数据库存储图片相对路径使用问题,配置tomcat的serve… 解决maven中静态资源只能放到properties中的问题 Mybatis出现错误org.apache.ibatis.e… 修改IDEA默认模板 tomcat启动与运行时出现中文乱码问题 IDEA配置Tomcat IDEA不自动提示仓库中有的包maven 软件设计文档 简单的字幕添加方法 hive表导出到mysql报错 Scrapy启动spider出错 C语言判断两个值相等 二维数组 三目运算符 C语言定义常量 C语言格式化输出语句 # 算法笔记 Best Cow Line 区间调度问题 硬币问题 迷宫最短路径 部分和问题 区间k大数训练 蓝桥杯基础练习
  • 最详细的Java知识点--缓冲流、转换流、序列化流、打印流
    缓冲流、转换流、序列化流、打印流主要内容缓冲流转换流序列化流打印流目标能够使用字节缓冲流读取数据到程序能够使用字节缓冲流写出数据到文件能够明确字符缓冲流的作用和基本用法能够使用缓冲流的特殊功能能够阐述编码表的意义能够使用转换流读取指定编码的文本文件能够使用转换流写入指定编码的文本文件能够说出打印流的特点能够使用序列化流写出对象到文件能够使用反序列化流读取文件到程序中第一章 缓冲流昨天学习了基本的一些流,作为IO流的入门,今天我们要见识一些更强大的流。比如能够高效读写的缓冲流,能够转换编码的转换流,能够持久化存储对象的序列化流等等。这些功能更为强大的流,都是在基本的流对象基础之上创建而来的,就像穿上铠甲的武士一样,相当于是对基本流对象的一种增强。1.1 概述缓冲流,也叫高效流,是对4个基本的FileXxx 流的增强,所以也是4个流,按照数据类型分类:字节缓冲流:BufferedInputStream,BufferedOutputStream字符缓冲流:BufferedReader,BufferedWriter缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组,通过缓冲区读写,减少系统IO次数,从而提高读写的效率。1.2 字节缓冲流构造方法public BufferedInputStream(InputStream in) :创建一个 新的缓冲输入流。public
  • 字节流和字符流(Byte Stream and Character stream)
    问题 请解释什么是字节流和字符流。 这些到底是什么意思? Microsoft Word文档是面向字节还是面向字符? 谢谢 回答1 流是顺序访问文件的一种方式。 字节流逐字节访问文件。 字节流适用于任何类型的文件,但不适用于文本文件。 例如,如果文件使用unicode编码,并且一个字符用两个字节表示,则字节流将分别处理这些字节,您需要自己进行转换。 字符流将逐字符读取文件。 必须为字符流提供文件的编码,以使其正常工作。 尽管Microsoft Word文档包含文本,但是无法使用字符流(它不是文本文件)进行访问。 您需要使用字节流来访问它。 回答2 ByteStreams : 从oracle文档页面中有关字节流的信息: 程序使用字节流执行8位字节的输入和输出。 所有字节流类都继承于InputStream和OutputStream 。 何时使用: 字节流仅应用于最原始的I / O 何时不使用: 您不应该使用字节流读取字符流 例如读取文本文件 字符流: 从oracle文档页面中有关字符流的信息: Java平台使用Unicode约定存储字符值。 字符流I / O会自动将此内部格式与本地字符集转换。 所有字符流类均来自Reader和Writer 。 字符流通常是字节流的“包装器”。 字符流使用字节流执行物理I / O,而字符流则处理字符和字节之间的转换。 有两个通用的字节到字符“桥”流:
  • 字节流和字符流详解
    1.流的概念 在编程中是一种抽象的概念,就好比“水流”,从一段流向另一端在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。 2.流的分类 按照流向可以分为:输入流(如:键盘,麦克风),输出流(如:显示器,音箱) 按照传输单位可以分为:字节流和字符流 3.什么是字节流,什么是字符流 字节流: 它处理单元为1个字节(byte),操作字节和字节数组,存储的是二进制文件,如果是音频文件、图片、歌曲,就用字节流好点(1byte = 8位); 字符流: 它处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符串,字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,如果是关系到中文(文本)的,用字符流好点(1Unicode = 2字节 = 16位); 所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。在读取文件(特别是文本文件)时,也是一个字节一个字节地读取以形成字节序列。 字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 2. 字节流提供了处理任何类型的IO操作的功能
  • JAVA I/O流的分类
    Java中 对文件的操作是以流的方式进行的。流是Java内存中的一组有序数据序列。Java将数据从源(文件、内存、键盘、网络)读入到内存中,形成了流,然后将 这些流还可以写到另外的目的地(文件、内存、控制台、网络),之所以称为流,是因为这个数据序列在不同时刻所操作的是源的不同部分。   二、分类   流的分类,Java的流分类比较丰富,刚接触的人看了后会感觉很晕。流分类的方式很多:   1、按照输入的方向分,输入流和输出流,输入输出的参照对象是Java程序。   2、按照处理数据的单位不同分,字节流和字符流,字节流读取的最小单位是一个字节(1byte=8bit),而字符流一次可以读取一个字符(1char = 2byte = 16bit)。   3、按照功能的不同分,分节点流和处理流,节点流是直接从一个源读写数据的流(这个流没有经过包装和修饰),处理流是在对节点流封装的基础上的 一种流,FileInputStream是一个节点流,可以直接从文件读取数据,但是BufferedInputStream可以包装 FileInputStream,使得其有缓冲功能。   其实除了以上三种分类外,还有一些常常听到的一些分类比如:对象流、缓冲流、压缩流、文件流等等。其实都是节点流和处理流的子分类。当然你也可以创建新的流类型,只要你需要。   三、流分类的关系   不管流的分类是多么的丰富和复杂
  • Java面试——基础——io——Java 中 IO 流分为几种?
    一、Java 中 IO 流分为几种 Java中的流分为两种,一种是字节流,另一种是字符流,分别由四个抽象类来表示(每种流包括输入和输出两种所以一共四个),Java中其他多种多样变化的流均是由它们派生出来的. 字节流:InputStream,OutputStream。 字符流: Reader,Writer。 二、字符流和字节流的区别 字符流和字节流是根据处理数据的类型的不同来区分的。 字节流按照8位传输,字节流是最基本的,所有文件的储存是都是字节(byte)的储存,在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。 字节流可用于任何类型的对象,包括二进制对象,而字符流只能处理字符或者字符串; 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。 理论上任何文件都能够用字节流读取,但当读取的是文本数据时,为了能还原成文本你必须再经过一个转换的工序,相对来说字符流就省了这个麻烦,可以有方法直接读取。所以,如果是处理纯文本数据,就要优先考虑字符流,除此之外都是用字节流。 来源:https://blog.csdn.net/peanutwzk/article/details/108463776
  • 【3】Java基础21-30
    目录 知识点21:java 中 IO 流分为几种? 知识点22:BIO、NIO、AIO 有什么区别? 知识点23:Files的常用方法都有哪些? 知识点24:Collection 和 Collections 有什么区别? 知识点25:HashMap 和 Hashtable 有什么区别? 知识点26:如何决定使用 HashMap 还是 TreeMap? 知识点27:说一下 HashMap 的实现原理? 知识点28:说一下 HashSet 的实现原理? 知识点29:ArrayList 和 LinkedList 的区别是什么? 知识点30:如何实现数组和 List 之间的转换? 知识点21:java 中 IO 流分为几种? 按功能来分:输入流(input)、输出流(output)。 按类型来分:字节流和字符流。 字节流和字符流的区别是:字节流按 8 位传输以字节为单位输入输出数据,字符流按 16 位传输以字符为单位输入输出数据。 知识点22:BIO、NIO、AIO 有什么区别? BIO:Block IO 同步阻塞式 IO,就是我们平常使用的传统 IO,它的特点是模式简单使用方便,并发处理能力低。 NIO:New IO 同步非阻塞 IO,是传统 IO 的升级,客户端和服务器端通过 Channel(通道)通讯,实现了多路复用。 AIO:Asynchronous IO 是 NIO 的升级,也叫
  • 了解getInputStream和getOutputStream(Understanding getInputStream and getOutputStream)
    问题 这是一个代码 import java.io.*; import java.net.*; public class Whois { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub int c; Socket s = new Socket("whois.internic.net",43); *InputStream in = s.getInputStream(); *OutputStream out = s.getOutputStream(); String str = (args.length == 0 ? "osborne.com" : args[0] ) + "\n"; byte buf[] = str.getBytes(); *out.write(buf); System.out.print("hey baby"); while ((c=in.read()) != -1) { System.out.print((char) c); } s.close(); } } 我已经标记了我理解有问题的语句。我不明白分配给s.getOutputStream()时out持有什么OutputStream对象以及通过out.write(buf
  • JAVA文件IO操作
    JAVA文件IO操作 学习札记 引子1、File类File类RandomAccessFile类 2、流类管道流ByteArrayInputStream和ByteArrayOutputStreamDataInputStream和DataOutputStream(数据字节输入流和数据字节输出流)SequenceInputStream文件合并流字节流与字符流的转化 3、字符编码4、对象序列化 发布于2019年09月06日 ⇲禁止转载于copy 笔记属于应用和基础原理层面,为浅谈;不涉及源代码解析。 引子 当我们要将Java程序中产生的数据永久性地保存起来的时候,应该想到的是将数据存到文件当中。将数据存入文件和将数据从文件中取出就涉及到了I/O的输入输出技术。Java提供了I/O操作可以将数据保存到多种类型的文件当中(当然每种特定格式的文件有其独特的构造方式和存取方式),本篇笔记将带你了解操作各种类型文件都具有的共同部分,了解了这些共同之处,就算遇到鲜有接触的文件格式也能灵活驾驭。 包括内容:File类、各种流类、字符的编码、对象序列化 1、File类 File类 是IO包中唯一代表磁盘文件本身的对象,进一步说就是File类起到了一个文件句柄的作用,所有对磁盘文件层面的操作都需要通过它,所有对磁盘文件的存取操作都需要先通过获取File类来完成
  • 史上最骚最全最详细的IO流教程,没有之一!
    目录 1、告白IO流的四点明确2、File类 1.1 File概述1.2 构造方法1.3 常用方法 1.3.1 获取功能的方法1.3.2 绝对路径和相对路径1.3.3判断功能的方法1.3.4 创建删除功能的方法1.4 目录的遍历1.5 递归遍历文件夹下所有文件以及子文件3、初探IO流 1.1 什么是IO1.2 IO的分类1.3 关于IO的分流向说明字节流OutputStream与InputStream的故事2.1 文件的世界里一切皆为字节2.2 字节输出流(OutputStream)2.3 字节输入流(InputStream)字符流Reader和Writer的故事字符流1、 字符输入流(Reader) FileReader类构造方法FileReader读取字符数据2、字符输出流(Writer) FileWriter类 构造方法FileWriter写出数据关闭close和刷新flushFileWriter的续写和换行FileReader和FileWriter类完成文本文件复制IO异常的处理1、缓冲流【掌握】 1.1 简要概述1.2 字节缓冲流 构造方法感受缓冲流的高效1.3 字符缓冲流 构造方法字符缓冲流特有方法1.4 字符缓冲流练习 代码实现2、转换流【掌握】 2.1 字符编码与解码字符集2.2 编码问题导致乱码2.3 InputStreamReader类-----
  • Java-IO框架汇总
    目录 流的分类 字节流 字节输入流 FileInputStream ObjectInputStream 字节输出流 FileOutputStream ObjectOutputStream 字节缓冲流 BufferedInputStream BufferedOutputStream 字符流 字符输入流 FileReader BufferedReader 字符输出流 流的分类 按照流向分为 输入流:从外部设备输入到内存中 输出流:从内存输出到外部设备 按照单位分为 字节流:以字节为单位,可以读所有数据 字符流:以字符为单位,只能读文本数据 按照功能分为 节点流:具有实际传输数据的读写功能 过滤流:在节点流的基础上增强功能 字节流 字节输入流 InputStream: 这个抽象类是表示输入字节流的所有类的超类。 常用实现类:FileInputStream、ObjectInputStream FileInputStream 用于读取诸如图像数据的原始字节流 常用构造方法 FileInputStream(File file) 通过打开与实际文件的连接创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。 FileInputStream(FileDescriptor fdObj) 创建 FileInputStream通过使用文件描述符 fdObj
  • java对象转化为流_Java I/O 流之转换流
    一、转换流简介 Reader 和 Writer 最重要的子类是 InputStreamReader 和 OutputStreamWriter 类。用来实现将字节流与字符流的相互转换,是字符流与字节流之间的桥梁。 1、InputStreamReader InputStreamReader 类包含了一个底层输入流,可以从中读取原始字节。它根据指定的编码方式,将这些字节转换为 Unicode 字符。构造方法: //创建一个使用默认字符集的 InputStreamReaderInputStreamReader(InputStream in){} //创建使用指定字符集的 InputStreamReaderInputStreamReader(InputStream in, String charsetName){}参数:InputStream in:字节输入流,用来读取文件中保存的字节 String charsetName:指定的编码表名称(不区分大小写,不指定默认使用utf-8)使用步骤:创建InputStreamReader对象,构造方法中传递字节输入流对象和指定的编码名称 使用InputStreamReader对象的方法read读取文件 释放资源 2、OutputStreamWriter OutputStreamWriter 从运行的程序中接收 Unicode 字¬
  • 字符编码看不懂你来打我!(ASCII,Unicode,Utf-8,GB2312…)
    这篇文章估计有些年头了,但作者确实将字符编码的发展历程介绍的很到位,偶然看到,突然觉得“相逢恨晚”,故转载——,也当做自己的收藏吧。 字符编码的问题看似很小,经常被技术人员忽视,但是很容易导致一些莫名其妙的问题。这里总结了一下字符编码的一些普及性的知识,希望对大家有所帮助。 1. 还是得从ASCII码说起 说到字符编码,不得不说ASCII码的简史。计算机一开始发明的时候是用来解决数字计算的问题,后来人们发现,计算机还可以做更多的事,例如文本处理。但由于计算机只识“数”,因此人们必须告诉计算机哪个数字来代表哪个特定字符,例如65代表字母‘A’,66代表字母‘B’,以此类推。但是计算机之间字符-数字的对应关系必须得一致,否则就会造成同一段数字在不同计算机上显示出来的字符不一样。因此美国国家标准协会ANSI制定了一个标准,规定了常用字符的集合以及每个字符对应的编号,这就是ASCII字符集(Character Set),也称ASCII码。 当时的计算机普遍使用8比特字节作为最小的存储和处理单元,加之当时用到的字符也很少,26个大小写英文字母还有数字再加上其他常用符号,也不到100个,因此使用7个比特位就可以高效的存储和处理ASCII码,剩下最高位1比特被用作一些通讯系统的奇偶校验。 注意,字节代表系统能够处理的最小单位,不一定是8比特。只是现代计算机的事实标准就是用8比特来代表一个字节
  • Java读取文件的不同方法(Java reading a file different methods)
    问题 似乎有很多方法可以读取Java中的文本文件( BufferedReader , DataInputStream等)。我个人最喜欢的是在构造函数中带有File Scanner (它更简单,可以更好地处理数学数据,并具有熟悉的语法) 。 蜘蛛侠鲍里斯(Boris the Spider)也提到Channel和RandomAccessFile 。 有人可以解释每种方法的利弊吗? 具体来说,我什么时候要使用它们? (编辑)我想我应该很具体,并补充说我对Scanner方法有很强的偏好。 所以真正的问题是,当我岂不要使用它? 回答1 让我们从头开始。 问题是你想做什么? 了解文件实际上是什么很重要。 文件是光盘上字节的集合,这些字节是您的数据。 Java提供了以上各种级别的抽象: File(Input|Output)Stream -阅读这些字节流byte 。 File(Reader|Writer) -从字节流中读取,作为char流。 Scanner -从char流中读取并标记化它。 RandomAccessFile将这些字节读取为可搜索的byte[] 。 FileChannel以安全的多线程方式读取这些字节。 在每个装饰的顶部都有装饰器,例如,您可以使用BufferedXXX添加缓冲。 您可以使用PrintWriter向FileWriter添加换行意识。
  • IO流--字符流写数据
    IO流是用来处理设备之间的数据传输的,诸如:文件的复制,上传下载文件Java中的流可以从不同的角度进行分类:- 按照流的方向不同:分为输入流和输出流。- 按照处理数据单位的不同:分为字节流和字符流。- 按照功能不同:分为节点流和处理流要区分字符流和字节流,我们可以从类名来区分类名中包含Reader:字符流 输入流类名中包含Writer:字符流 输出流类名中包含Input:字节流 输入流类名中包含Output:字节流 输出流包含Stream:字节流今天着重来看下字符流.Write顾名思义就是写的意思,FileWriter(String fileName) 指的是传递一个文件的名称成员方法:void write(String str) 往文件中写入一个字符串void flush() 刷新该流的缓冲,把内存缓冲区中的数据刷新到新的文件中去void close() 关闭此流,但是要先刷新它输出流写数据的一般步骤(也是最基本的步骤)1.创建输出流对象2.调用输出流对象写数据的方法3.刷新缓存,写入文件4.释放资源.举例:import java.io.FileWriter;import java.io.IOException;public class DemoFileWriter {public static void main(String[] args) throws