IO流基本知识
查看博客等级权益前置知识：字符集
/**
* 目标：掌握如何使用Java代码完成对字符的编码和解码。
*/
public class Test {
public static void main(String[] args) throws Exception {
// 1、编码
String data = "a我b";
byte[] bytes = data.getBytes(); // 默认是按照平台字符集（UTF-8）进行编码的。
System.out.println(Arrays.toString(bytes));
// 按照指定字符集进行编码。
byte[] bytes1 = data.getBytes("GBK");
System.out.println(Arrays.toString(bytes1));
// 2、解码
String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码
System.out.println(s1);
String s2 = new String(bytes1, "GBK");
System.out.println(s2);
}
}IO流
IO流总体来看就有四大流
- 字节输入流 : 以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流
- 字节输出流 : 以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流。
- 字符输入流 : 以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流。
- 字节输出流 : 以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流。
IO流-字节流
IO流的作用：就是可以对文件或者网络中的数据进行读、写的操作。
- 把数据从磁盘、网络中读取到程序中来，用到的是输入流。
- 把程序中的数据写入磁盘、网络中，用到的是输出流。
- 简单记：输入流（读数据）、输出流（写数据）
使用FileInputStream读取文件中的字节数据，步骤如下
第一步：创建FileInputStream文件字节输入流管道，与源文件接通。
第二步：调用read()方法开始读取文件的字节数据。
第三步：调用close()方法释放资源
/**
* 目标：掌握文件字节输入流，每次读取一个字节。
*/
public class FileInputStreamTest1 {
public static void main(String[] args) throws Exception {
// 1、创建文件字节输入流管道，与源文件接通。
InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));
// 2、开始读取文件的字节数据。
// public int read():每次读取一个字节返回，如果没有数据了，返回-1.
int b; // 用于记住读取的字节。
while ((b = is.read()) != -1){
System.out.print((char) b);
}
//3、流使用完毕之后，必须关闭！释放系统资源！
is.close();
}
}- FileInputStream（文件字节输入流）
作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去。
/**
* 目标：掌握使用FileInputStream每次读取多个字节。
*/
public class FileInputStreamTest2 {
public static void main(String[] args) throws Exception {
// 1、创建一个字节输入流对象代表字节输入流管道与源文件接通。
InputStream is = new FileInputStream("file-io-app\\src\\itheima02.txt");
// 2、开始读取文件中的字节数据：每次读取多个字节。
// public int read(byte b[]) throws IOException
// 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1.
// 3、使用循环改造。
byte[] buffer = new byte[3];
int len; // 记住每次读取了多少个字节。 abc 66
while ((len = is.read(buffer)) != -1){
// 注意：读取多少，倒出多少。
String rs = new String(buffer, 0 , len);
System.out.print(rs);
}
// 性能得到了明显的提升！！
// 这种方案也不能避免读取汉字输出乱码的问题！！
is.close(); // 关闭流
}
}- FileInputStream（文件字节输入流）
作用：以内存为基准，可以把磁盘文件中的数据以字节的形式读入到内存中去。
释放资源的方式
try-catch-finally
try{
....
....
}catch(Exception){
e.printStackTrace();
}finally{
//关流·写在这里
}
- finally代码区的特点：无论try中的程序是正常执行了，还是出现了异常，最后都一定会执行finally区，除非JVM终止。
- 作用：一般用于在程序执行完成后进行资源的释放操作（专业级做法）。
try-with-resource
try(定义资源1;定义资源2;…）{
可能出现异常的代码;
}
catch(异常类名 变量名){
异常的处理代码;
}
示例：
public class Demo {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("JavaSE_09\\src\\kun.png");
FileOutputStream fos = new FileOutputStream("JavaSE_09\\src\\kun2.png");
) {
byte[] bytes = fis.readAllBytes();
fos.write(bytes);
} catch (Exception e) {
e.printStackTrace();
}
}
}- 特点：该资源使用完毕后，会自动调用其close()方法，完成对资源的释放！
IO流-字符流
字符流的含义
- 字符流是指以字符为单位进行输入输出的数据流。在计算机中，字符流可以是从文件或网络连接中读取字符数据，也可以将字符数据写入文件或发送到网络连接中。
- 字符流通常用于处理文本数据，如读取或写入文本文件、网络通信中传输文本消息等。相比于字节流，字符流提供了更方便的操作字符串和字符的方法，能够直接读取和写入 Unicode 字符。
文件字符输入流-读字符数据进来
- 示例：
/**
* 目标：掌握文件字符输入流。
*/
public class FileReaderTest1 {
public static void main(String[] args) {
try (
// 1、创建一个文件字符输入流管道与源文件接通
Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
){
// 2、一个字符一个字符的读（性能较差）
// int c; // 记住每次读取的字符编号。
// while ((c = fr.read()) != -1){
// System.out.print((char) c);
// }
// 每次读取一个字符的形式，性能肯定是比较差的。
// 3、每次读取多个字符。（性能是比较不错的！）
char[] buffer = new char[3];
int len; // 记住每次读取了多少个字符。
while ((len = fr.read(buffer)) != -1){
// 读取多少倒出多少
System.out.print(new String(buffer, 0, len));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}文件字符输出流-写字符数据出去
- 字符输出流的特点：底层是有缓冲区的，字符输出流写出数据后，必须刷新流，或者关闭流，写出去的数据才能生效。
示例：
/**
* 目标：掌握文件字符输出流：写字符数据出去
*/
public class FileWriterTest2 {
public static void main(String[] args) {
try (
// 0、创建一个文件字符输出流管道与目标文件接通。
// 覆盖管道
// Writer fw = new FileWriter("io-app2/src/itheima02out.txt");
// 追加数据的管道
Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true);
){
// 1、public void write(int c):写一个字符出去
fw.write('a');
fw.write(97);
//fw.write('磊'); // 写一个字符出去
fw.write("\r\n"); // 换行
// 2、public void write(String c)写一个字符串出去
fw.write("我爱你中国abc");
fw.write("\r\n");
// 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
fw.write("我爱你中国abc", 0, 5);
fw.write("\r\n");
// 4、public void write(char[] buffer):写一个字符数组出去
char[] buffer = {'黑', '马', 'a', 'b', 'c'};
fw.write(buffer);
fw.write("\r\n");
// 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
fw.write(buffer, 0, 2);
fw.write("\r\n");
} catch (Exception e) {
e.printStackTrace();
}
}
}综合案列：
package com.itheima.demo02;
import java.io.FileReader;
import java.io.FileWriter;
public class Demo03 {
public static void main(String[] args) {
try (
// 1.创建字符输入流，读取c.txt
FileReader fr = new FileReader("JavaSE_10/file/c.txt");
// 2.创建字符输出流，写到d.txt
FileWriter fw = new FileWriter("JavaSE_10/file/d.txt")) {
// 3/创建一个字符数组，用于存储读取到的字符
char[] chars = new char[1024 * 8];
// 4.定义一个整数，用于记录读取的长度
int len;
// 5.使用循环读取数组，同时，把读取到的数据写入到d.txt
while ((len = fr.read(chars)) != -1) {
fw.write(chars, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
IO流-缓冲流
字节缓冲流
- 字节缓冲流的作用：提高字流的读写数据的性能。
- 原理：字节缓冲输入流自带了8KB缓冲池；字节缓冲输出流也自带了8KB缓冲池。
public class BufferedInputStreamTest1 {
public static void main(String[] args) {
try (
InputStream is = new FileInputStream("io-app2/src/itheima01.txt");
// 1、定义一个字节缓冲输入流包装原始的字节输入流
InputStream bis = new BufferedInputStream(is);
OutputStream os = new FileOutputStream("io-app2/src/itheima01_bak.txt");
// 2、定义一个字节缓冲输出流包装原始的字节输出流
OutputStream bos = new BufferedOutputStream(os);
){
byte[] buffer = new byte[1024];
int len;
while ((len = bis.read(buffer)) != -1){
bos.write(buffer, 0, len);
}
System.out.println("复制完成！！");
} catch (Exception e) {
e.printStackTrace();
}
}
}字符缓冲流
- 它的原理和字节缓冲流是类似的，它底层也会有一个8KB的数组，但是这里是字符数组。字符缓冲流也不能单独使用，它需要依赖于原始字符流一起使用。
- 字符缓冲输出流新增的功能：换行
public class BufferedReaderTest2 {
public static void main(String[] args) {
try (
Reader fr = new FileReader("io-app2\\src\\itheima04.txt");
// 创建一个字符缓冲输入流包装原始的字符输入流
BufferedReader br = new BufferedReader(fr);
){
// char[] buffer = new char[3];
// int len;
// while ((len = br.read(buffer)) != -1){
// System.out.print(new String(buffer, 0, len));
// }
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// System.out.println(br.readLine());
// System.out.println(br.readLine());
String line; // 记住每次读取的一行数据
while ((line = br.readLine()) != null){
System.out.println(line);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}public class BufferedWriterTest3 {
public static void main(String[] args) {
try (
Writer fw = new FileWriter("io-app2/src/itheima05out.txt", true);
// 创建一个字符缓冲输出流管道包装原始的字符输出流
BufferedWriter bw = new BufferedWriter(fw);
){
bw.write('a');
bw.write(97);
bw.write('磊');
bw.newLine();
bw.write("我爱你中国abc");
bw.newLine();
} catch (Exception e) {
e.printStackTrace();
}
}
}原始流、缓冲流的性能分析[重点]
- 数组越大性能越高，低级流和缓冲流性能相当
- 总结一下：缓冲流的性能不一定比低级流高，其实低级流自己加一个数组，性能其实是不差。
- 建议使用字节缓冲输入流、字节缓冲输出流，结合字节数组的方式，目前来看是性能最优的组合。
IO流-转换流
字符输入转换流
InputStreamReader（字符输入转换流）
- 解决不同编码时，字符流读取文本内容乱码的问题。
- 解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。
public class InputStreamReaderTest2 {
public static void main(String[] args) {
try (
// 1、得到文件的原始字节流（GBK的字节流形式）
InputStream is = new FileInputStream("io-app2/src/itheima06.txt");
// 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
Reader isr = new InputStreamReader(is, "GBK");
// 3、把字符输入流包装成缓冲字符输入流
BufferedReader br = new BufferedReader(isr);
){
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}字符输出转换流
OutputStreamWriter字符输出转换流
- 作用：可以控制写出去的字符使用什么字符集编码。
- 解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。
public class OutputStreamWriterTest3 {
public static void main(String[] args) {
// 指定写出去的字符编码。
try (
// 1、创建一个文件字节输出流
OutputStream os = new FileOutputStream("io-app2/src/itheima07out.txt");
// 2、把原始的字节输出流，按照指定的字符集编码转换成字符输出转换流。
Writer osw = new OutputStreamWriter(os, "GBK");
// 3、把字符输出流包装成缓冲字符输出流
BufferedWriter bw = new BufferedWriter(osw);
){
bw.write("我是中国人abc");
bw.write("我爱你中国123");
} catch (Exception e) {
e.printStackTrace();
}
}
}IO流-打印流
PrintStream/PrintWriter（打印流）
- 作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。
public class PrintTest1 {
public static void main(String[] args) {
try (
// 1、创建一个打印流管道
// PrintStream ps =
// new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
// PrintStream ps =
// new PrintStream("io-app2/src/itheima08.txt");
PrintWriter ps =
new PrintWriter(new FileOutputStream("io-app2/src/itheima08.txt", true));
){
ps.print(97); //文件中显示的就是:97
ps.print('a'); //文件中显示的就是:a
ps.println("我爱你中国abc"); //文件中显示的就是:我爱你中国abc
ps.println(true);//文件中显示的就是:true
ps.println(99.5);//文件中显示的就是99.5
ps.write(97); //文件中显示a，发现和前面println方法的区别了吗？
} catch (Exception e) {
e.printStackTrace();
}
}
}PrintStream和PrintWriter的区别
- 打印数据的功能上是一模一样的：都是使用方便，性能高效（核心优势）
- PrintStream继承自字节输出流OutputStream，因此支持写字节数据的方法。
- PrintWriter继承自字符输出流Writer，因此支持写字符数据出去。
IO流-数据流
DataOutputStream(数据输出流)
- 允许把数据和其类型一并写出去
public class DataOutputStreamTest1 {
public static void main(String[] args) {
try (
// 1、创建一个数据输出流包装低级的字节输出流
DataOutputStream dos =
new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt"));
){
dos.writeInt(97);
dos.writeDouble(99.5);
dos.writeBoolean(true);
dos.writeUTF("黑马程序员666！");
} catch (Exception e) {
e.printStackTrace();
}
}
}DataInputStream(数据输入流)
- 用于读取数据输出流写出去的数据
public class DataInputStreamTest2 {
public static void main(String[] args) {
try (
DataInputStream dis =
new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt"));
){
int i = dis.readInt();
System.out.println(i);
double d = dis.readDouble();
System.out.println(d);
boolean b = dis.readBoolean();
System.out.println(b);
String rs = dis.readUTF();
System.out.println(rs);
} catch (Exception e) {
e.printStackTrace();
}
}
}IO流-序列化流(对象流)
ObjectOutputStream(对象字节输出流)
- 可以把Java对象进行序列化：把Java对象存入到文件中去。
- 第一步：先准备一个User类，必须让其实现Serializable接口。
// 注意：对象如果需要序列化，必须实现序列化接口。
public class User implements Serializable {
private String loginName;
private String userName;
private int age;
// transient 这个成员变量将不参与序列化。
private transient String passWord;
public User() {
}
public User(String loginName, String userName, int age, String passWord) {
this.loginName = loginName;
this.userName = userName;
this.age = age;
this.passWord = passWord;
}
@Override
public String toString() {
return "User{" +
"loginName='" + loginName + '\'' +
", userName='" + userName + '\'' +
", age=" + age +
", passWord='" + passWord + '\'' +
'}';
}
}- 第二步：再创建ObjectOutputStream流对象，调用writeObject方法对象到文件。
public class Test1ObjectOutputStream {
public static void main(String[] args) {
try (
// 2、创建一个对象字节输出流包装原始的字节 输出流。
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt"));
){
// 1、创建一个Java对象。
User u = new User("admin", "张三", 32, "666888xyz");
// 3、序列化对象到文件中去
oos.writeObject(u);
System.out.println("序列化对象成功！！");
} catch (Exception e) {
e.printStackTrace();
}
}
}
//**注意：写到文件中的对象，是不能用记事本打开看的。因为对象本身就不是文本数据，打开是乱码**ObjectInputStream(对象字节输入流)
- 可以把Java对象进行反序列化：把存储在文件中的Java对象读入到内存中来。
public class Test2ObjectInputStream {
public static void main(String[] args) {
try (
// 1、创建一个对象字节输入流管道，包装 低级的字节输入流与源文件接通
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("io-app2/src/itheima11out.txt"));
){
User u = (User) ois.readObject();
System.out.println(u);
} catch (Exception e) {
e.printStackTrace();
}
}
}