知识点概要
- 字节流与字符流的概念
- 利用字节流对象完成文件读取和写入
一、Java IO简介
IO可以理解为“I/O”，可理解为In和Out，即输入与输出。所以，IO体系的基本功能就是读和写。
IO流：
- 作用：读写设备上的数据，硬盘文件、内存、网络、键盘等。
- 根据数据的走向：输入流和输出流
- 根据处理的数据类型：字节流和字符流
字节流：可以处理所有类型的数据，如MP3、图片、文字、视频等。 在读取时，读到一个字节就返回一个字节。
==在Java中，对应的类都是以stream结尾。==
字符流：仅能够处理纯文本数据，如txt文本等。在读取时，读到一个或多个字节，先查找指定的编码表，然后将查到的字符返回。
二、字符、字节与编码
字节（Byte）:通过网络传输信息或内存中存储信息的单位，是计算机信息技术用于计量存储和传输容量的一种计量单位。
一字节等于8位二进制，即一个8位的二进制数，是一个很具体的存储空间。如0x01,0x45,0xFA...
字符（Char）:字符是人们使用的记号，是抽象意义上的一个符号。
字符集（Charset）:字符集也叫做编码。编码标准中规定所包含字符的集合就是字符集。规定每个字符分别用一个字节还是多个字节存储，用那些字节存储，这个规定就叫做“编码”。
ANSI：字符串在内存中，如果“字符”是以ANSI编码形式存在的，一个字符可能用一个字节或者多个字节来展示，那么我们称这种字符串为“ANSI”字符串或多字节字符串。不同ANSI编码所规定的标准是不同的，因此，对于一个给定的多字节字符串，我们必须知道它采用的是哪一种编码规则，才能够知道它包含了哪些“字符”。
Unicode：字符串在内存中，如果字符是以Unicode中的序号存在的，那么我们称折中字符串为Unicode字符串或者宽字节字符串。对于Unicode字符串来说，不管在什么环境下，它所代表的内容总是不变的。用来给Unicode字符集编码的标准有很多种，比如UTF-8等。
三、使用字节流读取数据
准备文本文件hello.txt，存放的路径为src/files/readTestFile.txt，里面的内容如下：
hello world
小飞侠
案例1：文件读取
public class ReadByteStream {
public static void main(String[] args) {
try {
// 创建文件读入字节流对象，用文件的路径参数进行初始化
FileInputStream fs = new FileInputStream("src/files/readTestFile.txt");
// 字节数组作为读入数据的缓冲区
byte input[] = new byte[100];
// 将数据读取到input数组中
String str;
while (fs.read(input) != -1) {
str = new String(input, "UTF-8");
// str = new String(input, "GBK");
System.out.println(str);
}
// 关闭文件读入字节流对象
fs.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试1：
使用str = new String(input, "UTF-8");读取输出如下：
hello world
小飞侠
中文显示正常。
测试2：
使用str = new String(input, "GBK");读取输出如下：
hello world
灏忛渚�
中文显示出现了乱码。这是因为写入的时候采用了UTF-8进行编码，读取的时候却强制使用了GBK进行解码，自然导致读取出来的内容发生错乱。
代码实例2：文件写入
public class WriteByteStream {
public static void main(String[] args) {
try {
// 待写入的内容
String outString = "write by 小飞侠";
// 创建文件输出流对象
FileOutputStream fos = new FileOutputStream("src/files/writeTestFile.txt");
// 输出缓冲区
byte output[] = outString.getBytes("UTF-8");
// 从缓冲区写入到流对象，并刷新流写入到文件
fos.write(output);
fos.flush();
// 关闭输出流对象
fos.close();
System.out.println("done");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试1：
writeTestFile.txt中内容如下，且多次写入会发生内容覆盖
write by 小飞侠
代码实例3：文件拷贝
package com.netease.fileIO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 功能描述：利用字节流对象实现文件拷贝
*
* @author louxj424
*
*/
public class CopyByteStream {
public static void main(String[] args) {
try {
// 创建文件的读入和写入字节流对象，并用文件位置进行初始化
FileInputStream fis = new FileInputStream("src/pictures/pic1.jpg");
FileOutputStream fos = new FileOutputStream("src/pictures/pic1_new.jpg");
// 缓冲区的字节数组
byte input[] = new byte[100];
// read正常的返回值为成功写入到byte数组的字节数，如果返回-1则说明写完了。
while (fis.read(input) != -1) {
fos.write(input);
}
// 关闭文件读入和写入流
fos.close();
fis.close();
System.out.println("done");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试结果：
刷新工程目录后，pictures文件夹下出现了新文件pic1_new.jpg文件。
四、使用带有缓冲区的字节流读取数据
package com.netease.fileIO;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 使用BufferedInputStream，通过缓存读取大文件。
* 在代码编写的过程中，通过不断地调整缓冲区以及数组的大小，找到一个合适的数值，前者影响磁盘读写次数，后者影响处理时间。
*
* @author louxj424
*
*/
public class ReadByBuffertoStream {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
// 带有缓冲的输入输出流的读写效率是非常高的。
FileInputStream fis = new FileInputStream("src/JavaCode.pdf");
BufferedInputStream bis = new BufferedInputStream(fis, 10000);
FileOutputStream fos = new FileOutputStream("src/NewJavaCode.PDF");
BufferedOutputStream bos = new BufferedOutputStream(fos, 10000);
// 大型文件对应的数组应该大一些，小文件的数组应当小一些，在实践中不断尝试和优化。
byte input[] = new byte[10000];
int count = 0;
long startTime = System.currentTimeMillis();
while (bis.read(input) != -1) {
bos.write(input);
count++;
// System.out.println("文件读取完毕！");
}
bos.close();
fos.close();
bis.close();
fis.close();
long endTime = System.currentTimeMillis();
System.out.println("读取了" + count + "次");
System.out.println("耗时" + (float) (endTime - startTime) / (1000) + "秒");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
五、使用字符流写数据
代码实例：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
/**
* 利用字符流读写文件实现文本文件的拷贝功能
*
* @author louxj424
*
*/
public class CopyByCharStream {
public static void main(String[] args) {
try {
// 将创建的文件对象传入文件输入流，该流为字节流
FileInputStream fis = new FileInputStream("src/files/readTestFile.txt");
FileOutputStream fos = new FileOutputStream("src/files/writeTestFile.txt");
// 将字节流转换为字符流，指定字符集
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
// 创建一个字符数组
char input[] = new char[100];
int len = 0;
// read函数的正常返回值为实际读取的字符数组的长度，-1代表已经读取到了文件末尾
while ((len = isr.read(input)) != -1) {
/*
* 第一个参数代表偏移量，参数值0表示从字符数组的开始位置读取; 第二个参数为读取的长度，值l为read()函数的返回值.
*/
String inputString = new String(input, 0, len);
// System.out.println(inputString);
osw.write(inputString);
}
// 关闭流，后打开的先关闭，先打开的后关闭
isr.close();
osw.close();
fos.close();
fis.close();
System.out.println("Done");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
六、使用带有缓冲的字符流读写数据
代码实践：
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
/**
* 演示：使用带有缓冲的字符流读写数据
*
* @author louxj424
*
*/
public class ReadWriteByBufferedStream {
public static void main(String[] args) {
try {
// 将创建的文件对象传入文件输入流，该流为字节流
FileInputStream fis = new FileInputStream("src/files/readTestFile.txt");
FileOutputStream fos = new FileOutputStream("src/files/writeTestFile.txt");
// 将字节流转换为字符流，指定字符集
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
BufferedReader br = new BufferedReader(isr);
// 自带缓冲区，当缓冲区被写满之后才会向硬盘真正写入数据，写入效率增加
// BufferedWriter bw=new BufferedWriter(osw);
/*
* out A character-output stream autoFlu * sh A boolean; if true,
* the println, printf, or format methods will flush the output
* buffer
*/
PrintWriter pw = new PrintWriter(osw, true);
// 读取文件的一行数据，返回null说明读取到了文件末尾
String input;
while ((input = br.readLine()) != null) {
// bw.write(input);
pw.println(input);
}
// 将缓冲区内容强制输出，以免造成缓冲区未写满程序关系造成数据丢失
pw.flush();
br.close();
// bw.close();
pw.close();
// 关闭流，后打开的先关闭，先打开的后关闭
isr.close();
osw.close();
fos.close();
fis.close();
System.out.println("Done");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
七、FileReader与FileWriter
代码示例：
package com.netease.fileIO;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import jdk.jfr.events.FileWriteEvent;
public class TestFileReadWriter {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
// 读取文件的文本数据
FileReader fr = new FileReader("src/new Hello.txt");
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter("src/new Hello2.txt");
BufferedWriter bw = new BufferedWriter(fw);
String line;
while ((line = br.readLine()) != null) {
bw.write(line + "\n");
}
bw.flush();
bw.close();
fw.close();
br.close();
fr.close();
System.out.println("Done");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
八、读取配置文件参数信息
package com.netease.java.learn.IO.file;
import java.io.InputStream;
import java.util.Properties;
/**
* 配置文件键值对信息读取示例
*
* @author louxj424
*
*/
public class PropertiesLoader {
private static final String DB_DRIVER = "DB_DRIVER";
private static final String DB_URL = "DB_URL";
private static final String DB_USER = "DB_USER";
private static final String DB_PASSWORD = "DB_PASSWORD";
// 这里路径写法适用于配置文件与源码文件不在一个文件目录的情形，使用的是绝对目录的表示方法，
// 这里的"/"表示的src的根目录
private static final String PROPERTIES_FILE = "/files/jdbc.properties";
private static String driver;
private static String url;
private static String username;
private static String password;
public static void main(String[] args) {
// 用来保存属性文件中中的键值对
Properties properties = new Properties();
try {
// 读取属性文件中的内容，将其读取到一个输入流中
// 使用详解介绍可以参考文章：https://www.cnblogs.com/macwhirr/p/8116583.html
InputStream is = PropertiesLoader.class.getResourceAsStream(PROPERTIES_FILE);
// 从输入流中读取属性列表：属性文件中的键值对列表
properties.load(is);
} catch (Exception e) {
e.printStackTrace();
System.out.println("=================配置文件读取错误=================");
}
// 将读取到的值赋值给类的成员变量
driver = properties.getProperty(DB_DRIVER);
url = properties.getProperty(DB_URL);
username = properties.getProperty(DB_USER);
password = properties.getProperty(DB_PASSWORD);
System.out.println(DB_DRIVER + ":" + driver);
System.out.println(DB_URL + ":" + url);
System.out.println(DB_USER + ":" + username);
System.out.println(DB_PASSWORD + ":" + password);
}
}
src/files/jdbc.properties目录下的配置文件内容信息如下：
DB_DRIVER=com.mysql.jdbc.Driver
DB_URL=jdbc:mysql://localhost/jsp_db
DB_USER=root
DB_PASSWORD=123456