I/O流原理
- I/O 是 Input / Output 的缩写，I / O 流技术是非常实用的技术，用于处理数据传输。如读/写文件，网络通讯等；
- Java中对于数据的输入/输出操作以"流(stream)"的方式进行；
- Java.io 包下提供了各种"流"类和接口，用以获取不同种类的数据，并通过方法输入或输出数据；
- 输入input：读取外部数据（如磁盘数据）到程序（内存）中；
- 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。
流的分类
- 按操作数据单位不同分为：字节流（8 bit）二进制文件，字符流（按字符）文本文件；
- 按数据流的流向不同分为：输入流，输出流；
- 按流的角色的不同分为：字节流，处理流/包装流。
| 抽象基类 | 字节流 | 字符流 |
| :------: | :----------: | :----: |
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
- java的IO流共涉及40多个类，实际上非常规则，都是从上面四个抽象基类派生的；
- 以这四个派生出来的子类都以父类名作为子类名的后缀。（如FileInputStream、ObjectOutputStream、BufferedReader、StringWriter等）
InputStream:字节输入流
InputSteam抽象类是所有字节输入流类的父类(超类、基类)。
InputStream类常用的子类
- FileInputStream:文件输入流
- BufferedInputSream:缓冲字节输入流
- ObjectInputStream:对象字节输入流
FileInputStream例题1：
使用FileInputStream读取hello.test文件，并将文件内容显示到控制台
package IOStream.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* @author yeye
* @desc FileInputStream的使用（字节输入流 文件--->程序）
* @date 2024/8/20 16:57
*/
public class FileInputStream_ {
public static void main(String[] args) {
FileInputStream_ fileInputStream = new FileInputStream_();
fileInputStream.readFile01();
fileInputStream.readFile02();
}
/**
* 单个字节的读取，概率比较低
* */
public void readFile01() {
String filePath = "C:\\app\\hello.txt";
int readDate = 0;
FileInputStream fileInputStream = null;
try {
// 创建FileInputStream对象,用于读取文件
fileInputStream = new FileInputStream(filePath);
//从该输入流读取一个字节的数据，如果没有输入可以，此方法将阻止。
//返回读取的字节数，如果到达文件末尾，则返回-1
while ((readDate = fileInputStream.read())!= -1) { // 读取文件内容
System.out.print((char) readDate);
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 使用read(byte[] b)方法，一次性读取多个字节，提高效率
*/
public void readFile02() {
String filePath = "C:\\app\\hello.txt";
int readLen = 0;
//字节数组，用于存储读取的文件内容
byte[] buffer = new byte[4]; //一次性读取4个字节
FileInputStream fileInputStream = null;
try {
// 创建FileInputStream对象,用于读取文件
fileInputStream = new FileInputStream(filePath);
//从该输入流最多读b.length个字节，将读取的内容存储在b数组中，返回实际读取的字节数。
//如果读取的字节数小于b.length，说明到达了文件末尾
//如果返回值为-1，则说明读取完毕
//如果读取正常，返回实际读取的字节数
while ((readLen = fileInputStream.read(buffer))!= -1) { // 读取文件内容
System.out.print(new String(buffer, 0, readLen));
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭文件流，释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
OutputStream类
FileOutputStream例题1：
使用FileOutputStream在test.txt文件中写入"hello,world",如果文件不存在，则会创建文件
package IOStream.OutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutPutStream01 {
public static void main(String[] args) {
FileOutPutStream01 fil = new FileOutPutStream01();
fil.writeFile();
}
/**
* 使用FileOutputStream将数据写入文件
* 如果文件不存在，则创建该文件
*/
public void writeFile(){
// 创建FileOutputStream对象
String filePath = "E:/test.txt";
FileOutputStream fileOutPutStream = null;
try {
//得到FileOutputStream对象
//1.new FileOutputStream(filePath)创建方式，会覆盖原文件
//2.new FileOutputStream(filePath,true)创建方式，不会覆盖原文件，在文件末尾追加内容
fileOutPutStream = new FileOutputStream(filePath);
//写入一个字节
fileOutPutStream.write('a');
//写入一个字符串
String str = "hello world";
//str.getBytes();可以把字符串转换为字节数组
//fileOutPutStream.write(str.getBytes());
//write(byte[] b, int off, int len)方法，可以指定写入的起始位置和长度
fileOutPutStream.write(str.getBytes(), 0, 5);
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fileOutPutStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
FileOutputStream例题2：
编程完成图片/音乐的拷贝
package IOStream.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author yeye
* @desc
* @date 2024/8/20 19:10
*/
public class FileCopy {
public static void main(String[] args) {
//完成文件拷贝，将e：\dog1.jpg文件拷贝到c:\dog.jpg
/**
* 1.创建文件的输入流，将文件读取的程序
* 2.创建文件的输出流，将读取到的文件数据写入到指定的文件
* 在完成程序时，应该是读取部分数据，就写入到值得文件，这里使用循环
*/
//读取文件的路径
String srcfilePath = "e:\\dog1.jpg";
String destfilePath = "e:\\dog01.jpg";
FileInputStream fileInputStream = null;
FileOutputStream fileOutputStream = null;
try {
fileInputStream = new FileInputStream(srcfilePath);
fileOutputStream = new FileOutputStream(destfilePath);
//定义一个字节数组，提高读取效率
byte[] buffer = new byte[1024];
int ReadLen = 0;
while ((ReadLen = fileInputStream.read(buffer))!= -1){
//读取到数据后，就通过fileOutputStream写入到指定的文件
fileOutputStream.write(buffer,0,ReadLen);
}
System.out.println("文件拷贝成功！");
} catch (IOException e) {
e.printStackTrace();
}finally {
try{
//关闭输入流和输出流，释放资源
if(fileInputStream!= null){
fileInputStream.close();
}
if (fileOutputStream!= null){
fileOutputStream.close();
}
}catch (IOException e){
e.printStackTrace();
}
}
}
}
Reader常用的类、Writer常用的类
FileReader和FileWriter
1.FileReader常用方法
- new FileReader(File/String)
- read():每次读取单个字符，返回该字符，如果文件末尾，返回-1
- read(char []):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1
相关API：
- new String ( char [] ) : 将char转换成String
- new String ( char [] ,off,len) : 将char [ ] 值得的部分转换成String
3.FileReader应用案例
要求：1.使用FileReader从story.txt读取内容并显示
package IOStream.Reader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* @author yeye
* @desc
* @date 2024/8/20 22:30
*/
public class FileReader01 {
public static void main(String[] args) {
//方法1 --read()方法
String filePath = "e:\\story.txt";
FileReader fileReader = null;
int date =' ';
//创建FileReader对象
try {
fileReader = new FileReader(filePath);
//读取文件内容--循环读取--使用read()方法,单个读取
while((date = fileReader.read()) !=-1){
System.out.print((char)date);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fileReader!= null){
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
// //方法2 --read(buffer)方法
// String filePath = "e:\\story.txt";
// FileReader fileReader = null;
// int ReadLen = 0;
// char[]buffer = new char[8];
// //创建FileReader对象
// try {
// fileReader = new FileReader(filePath);
// //读取文件内容--循环读取--使用read(buffer)方法,批量读取
// //返回的是实际读取到的字符数
// //如果返回-1,表示已经读取到文件末尾
// while((ReadLen = fileReader.read(buffer)) !=-1){
// System.out.print(new String(buffer,0,ReadLen));
// }
//
// } catch (IOException e) {
// e.printStackTrace();
// }finally {
// if(fileReader!= null){
// try {
// fileReader.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// }
}
}
2.FileWriter常用方法：
- new FileWriter(File/String) : (对象/地址) 覆盖模式，每写一次都会覆盖之前的内容，相当流的指针在首端
- new FileWriter(File/String,true) : 追加模式，在原内容尾端输入内容，相当于指针在尾端
- writer(int) : 写入单个字符
- write(char [] ) : 写入指定数组
- write(char []，off,len) :写入指定数组的指定部分
- writer(String) : 写入整个字符串
- writer(String，off,len) : 写入字符串的指定部分
相关API：String类 ： toCharArray:将String类转换成char[]
注：FileWriter在使用后，必须关闭（close）或者刷新（flush),否则写入不到指定文件。
3.FileWriter应用案例
要求：使用FileWriter将"你好，Java！"写入到note.txt文件中，
package IOStream.Writer;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author yeye
* @desc
* @date 2024/8/20 23:03
*/
public class FileWriter01 {
public static void main(String[] args) {
String filePath = "E:/test.txt";
//创建一个FileWriter对象，用于写入文件
FileWriter fileWriter = null;
char [] buffer = {'h', 'e', 'l', 'l', 'o'};
try {
fileWriter = new FileWriter(filePath); //默认是覆盖写入
//1. writer(int) : 写入单个字符
fileWriter.write('a');
//2. write(char [] ) : 写入指定数组
fileWriter.write(buffer);
//3. write(char []，off,len) :写入指定数组的指定部分
fileWriter.write("椰椰在努力学Java".toCharArray(), 1, 9);
//4. writer(String) : 写入整个字符串
fileWriter.write("你好，Java！");
//5. writer(String，off,len) : 写入字符串的指定部分
fileWriter.write("你好，成都！", 0, 3);
//在数据量大的情况下，可以使用循环操作
} catch (IOException e) {
e.printStackTrace();
}finally {
//对应FileWriter,一定要关闭（close),或者刷新（flush）才能正真把数据写入文件
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
节点流和处理流
节点流
节点流可以从一个特定的数据源（如文本、数组、字符串、管道等）读写数据，如FileReader、FileWriter、FileInputStream、FileOutputStream等
灵活性低
处理流
处理流也叫包装流，是"连接"在已存在的流（节点流或处理流）之上，为程序提供更为强大的功能，也更加灵活如BufferedReader、BufferedWriter.
public class BufferedReader extends Rander{
private Reader in;
private char cb[];
}
//BufferedReader类中，有属性Reader，即可以封装任何一个节点流，只要该节点流是Reader类的子类
public class BufferedWriter extends Writer{
private Writer out;
private char cb[];
}
//BufferedWriter类中，有属性Writer，即可以封装任何一个节点流，只要该节点流是Reader类的子类
节点流和处理流的区别和联系
- 节点流是底层流/低级流，直接跟数据源相连；
- 处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更为方便的方法来完成输入输出。
- 处理流（包装流）对节点流进行包装，使用了修饰器设计模式，不会直接跟数据源相连
处理流的功能主要体现在以下两个方面： - 性能的提高：主要以增加缓存的方式来提高输入输出的效率；
- 操作的便捷：处理流可提供一系列便捷的方法来输入输出大批量的数据，使用起来更加的灵活。
处理流大概实现如下：
//抽象父类
public abstract class Reader_ {
public void readFile(){}
public void readString(){}
}
//节点流————直接读取源文件
public class FileReader_ extends Reader_{
public void readFile(){
System.out.println("正在读取文件...");
}
}
//节点流————直接读取字符串
public class StringReader_ extends Reader_ {
public void readString(){
System.out.println("正在读取字符串");
}
}
//处理流（包装流）
public class BufferedReader_ extends Reader_ {
private Reader_ reader_; //Reader_类型的reader_属性
//接受Reader_子类对象
public BufferedReader_(Reader_ reader_){
this.reader_ = reader_;
}
//让方法更加灵活，多次读取文件,或者加缓冲char[]...
public void readLines(int num){
for(int i = 0;i<num;i++){
reader_.readFile();
}
}
//扩展readString,批量读取字符串
public void readStrings(int num){
for(int i = 0;i<num;i++){
reader_.readString();
}
}
}
public class Test {
public static void main(String[] args) {
BufferedReader_ bufferedReader = new BufferedReader_(new FileReader_());
bufferedReader.readLines(10);
BufferedReader_ bufferedReader1 = new BufferedReader_(new StringReader_());
bufferedReader1.readStrings(10);
}
}
处理流—— BufferedReader和BufferedWriter
- BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的；
- 关闭处理流时，只需关闭外层流即可。
例1：使用BufferedReader读取文本文件，并显示在控制台
package IOStream.Reader;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReader02 {
public static void main(String[] args) throws IOException {
String filePath ="E:/BufferedReader_.txt";
// 创建BufferedReader对象
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
// 读取文件内容
String line ;//按行读取，效率高
//bufferedReader.readLine()是按行读取
//当返回null时，表示已经读取到文件末尾
while((line = bufferedReader.readLine()) !=null){
System.out.println(line);
}
// 关闭流，只需关闭外层流（BufferedReader）即可，因为底层会自动关闭节点流（FileReader）
bufferedReader.close();
}
}
例2：使用BufferedWriter 将"hello,JAVA"写入到文件中
package IOStream.Writer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriter02 {
public static void main(String[] args) throws IOException {
String filePath = "E:\\test.txt";
//创建BufferedWriter对象
/**
* new FileWriter(filePath)表示以覆盖的方式写入
* new FileWriter(filePath,true)表示以追加的方式写入
*/
BufferedWriter bufferedWriter02 = new BufferedWriter(new FileWriter(filePath,true));
//写入数据
bufferedWriter02.write("Hello JAVA!");
//插入一个和系统相关的换行
bufferedWriter02.newLine();
bufferedWriter02.write("Hello 椰椰!");
//关闭外层流(BufferedWriter)即可，传入的new FileWriter(filePath)会在底层关闭
bufferedWriter02.close();
}
}
例3：综合使用BufferedReader和BufferedWriter完成文本文件拷贝
package IOStream.Writer;
import java.io.*;
public class BufferedReader_BufferedWriter_01 {
public static void main(String[] args) throws IOException {
/**
* BufferedReader和BufferedWriter是按照字符操作
* 不要操作二进制文件，可能会造成文件损坏
*/
String srcFilePath = "E:\\test.txt";
String destFilePath = "E:\\test_copy.txt";
//创建BufferedReader对象
BufferedReader bufferedReader = new BufferedReader(new FileReader(srcFilePath));
//创建BufferedWriter对象
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
//读取文件内容并写入到目标文件中
String line;
//readLine()方法读取一行内容，没有换行
while ((line = bufferedReader.readLine())!= null){
bufferedWriter.write(line);
//插入一个换行
bufferedWriter.newLine();
}
if(bufferedReader!=null){
bufferedWriter.close();
}
if(bufferedWriter!=null){
bufferedWriter.close();
}
System.out.println("文件拷贝成功！");
}
}
处理流——BufferedInputStream和BufferedOutputStream
BufferedInputStream是字节流，在创建BufferedInputStream时，会创建一个内部缓冲数组
BufferedOutputStream是字节流，实现缓冲的输出流，可以将多个字节写入底层的输出流中，而不必对每次字节写入调用底层系统
例1：编程完成图片/音乐/文本文件的拷贝，（此处以图片为例，音乐/文本文件只需改变相应地址即可）
package IOStream.OutputStream;
import java.io.*;
public class BufferedInputStream_BufferedOutputStream_001 {
public static void main(String[] args) throws IOException {
String scrFilePath = "E:/dog01.jpg";
String destFilePath = "E:/dog01_copy.jpg";
//创建BufferedInputStream对象和BufferedOutputStream对象
//FileInputStream是InputStream的子类，BufferedInputStream是FilterInputStream的子类
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(scrFilePath));
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
//循环读取文件，并写入到destFilePath中
byte [] buffer = new byte[1024];
int len = 0;
//当返回值是-1时，表示文件已经读取完毕
while((len = bufferedInputStream.read(buffer)) != -1){
bufferedOutputStream.write(buffer,0,len);
}
System.out.println("文件拷贝成功！");
//关闭流外层处理流，底层会关闭节点流
if(bufferedInputStream !=null){
bufferedInputStream.close();
}
if(bufferedOutputStream != null){
bufferedOutputStream.close();
}
}
}
处理流——（对象流）———ObjectInputStream和ObjectOutputStream
看一个需求：
- 将int num = 100 这个 int 数据保存到文件中,注意不是 100 数字，而是 int 100，并且，能够从文件中直接恢复 int 100
- 将 Dog dog = new Dog(“小黄”, 3) 这个 dog对象 保存到 文件中，并且能够从文件恢复.上面的要求，就是 能够将 基本数据类型 或者 对象 进行 序列化 和 反序列化操作
功能：提供了对基本类型或对象类型的序列化和反序列化
- ObjectOutputStream提供了 序列化功能
- ObjectInputStream 提供了反序列化功能
注意事项：
- 读写顺序要一致;
- 实现序列化或反序列化，要实现Serializable;
- 序列化的类建议添加SerialVersionUID,为了提高版本的兼容性；
- 序列化对象时，默认将里面所有的属性都进行序列化，除了static、transient修饰的成员；
- 序列化对象时，要求里面属性的类型也需要实现序列化接口；
- 序列化具备可继承性，也就是某类已经实现了序列化，则它所有的子类也以及默认实现了序列化。
序列化和反序列化
- 序列化就是在保存数据时，保存数据的值和数据类型；
- 反序列化就是在恢复数据时，恢复数据的值和数据类型。
- 需要让某个对象支持序列化机制，就必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现以下两个接口之一：
- Serializable //一个标记接口，没有方法，一般实现这个接口
- Externalizable //该方法有方法需要实现
例1：使用ObjectOutputStream 序列化基本数据类型和一个Dog对象（name,age),并保存到一个文件中。
package IOStream.OutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @author yeye
* @desc 使用ObjectOutputStream 完成数据的序列化
* @date 2024/8/22 13:59
*/
public class ObjectOutputStream01 {
public static void main(String[] args) throws IOException {
//序列化后保存到文件格式，不是文本格式，而是按照它的格式保存
String filePath = "E:/data.dat";
//创建ObjectOutputStream对象
ObjectOutputStream obj= new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到E/data.dat
obj.writeInt(10); //int - >Integer (实现了Serializable接口）
obj.writeBoolean(true); //boolean -> Boolean(实现了Serializable接口）
obj.writeChar('a'); //char -> Character(实现了Serializable接口）
obj.writeDouble(3.1415926); //double -> Double(实现了Serializable接口）
obj.writeUTF("Hello 椰椰"); //String(实现了Serializable接口）
//保存一个dog对象
obj.writeObject(new Dog("小宝",3));
//关闭流
obj.close();
System.out.println("序列化完成");
}
}
//如果要序列化某个类的对象，该类必须实现Serializable接口
class Dog implements Serializable {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
例2：使用ObjectInputStream读取data.dat并反序列化恢复数据。
package IOStream.InputStream;
import polymorphism.Dog;
import java.io.*;
/**
* @author yeye
* @desc 使用ObjectInputStream读取data.dat并反序列化恢复数据。
* @date 2024/8/22 14:39
*/
public class ObjectInputStream01 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//指定反序列化文件
String filePath = "E:/data.dat";
//创建ObjectInputStream对象
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(filePath));
//读取（反序列化）的顺序需要和写入（序列化）顺序保持一致，否则会出现异常
System.out.println(obj.readInt());
System.out.println(obj.readBoolean());
System.out.println(obj.readChar());
System.out.println(obj.readDouble());
System.out.println(obj.readUTF());
//dog编译类型是Dog,dog运行类型是Dog
Object dog = obj.readObject();
System.out.println("运行类型：" + dog.getClass());
System.out.println("dog信息：" + dog); //底层Object - >Dog
//如果我们希望调用dog的方法，就需要向下转型
//需要我们将Dog类的定义，拷贝到可以引用的位置
}
}
标准输入输出流
package IOStream.Standard;
import java.util.Scanner;
/**
* @author yeye
* @desc
* @date 2024/8/22 15:49
*/
public class InputAndOutput {
public static void main(String[] args) {
//System 类的public final static InputStream in = null;
//编译类型：InputStream
//运行类型：BufferedInputStream
//表示标准输入，键盘
System.out.println(System.in.getClass());
//System 类的public final static PrintStream out属性;
//编译类型：PrintStream
//运行类型：PrintStream
//表示标准输出，显示器
System.out.println(System.out.getClass());
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容：");
String next = scanner.next();
System.out.println("你输入的内容是：" + next);
}
}
//运行结果：
class java.io.BufferedInputStream
class java.io.PrintStream
请输入内容：
nihao
你输入的内容是：nihao
转换流——InputStreamReader和OutputStreamWrider
transformation - 转型
- InputStreamReader：是Reader类的子类，可以将InputStream（字节流）包装/转换成Reader(包装流)；
- OutputStreamWriter：是Writer类的子类，实现将OutputStream（字节流）包装/转换成Writer(包装流)；
- 当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，建议将字节流转换成字符流
- 可以在使用时指定编码格式（比如 utf-8、gbk、gb2312等）
例1：将字节流 FileInputStream 包装/转换成 InputStreamReader，对文件进行读取（按照utf-8/gbk),进而再包装成BufferedReader
package transformation;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @author yeye
* @desc 使用InputStreamReader 转换流解决中文乱码问题
* 将字节流FileInputStream转换为字符流InputStreamReader，并指定编码格式为UTF-8/GDK，即可解决中文乱码问题。
* @date 2024/8/22 16:43
*/
public class InputStreamReader01 {
public static void main(String[] args) throws IOException {
String filePath = "E:/aaa.txt";
//第一步：把new InputStreamReader 转成 InputStreamReader流，并指定编码格式为GBK
InputStreamReader in1 = new InputStreamReader(new FileInputStream(filePath), "gbk");
//第二步：把InputStreamReader 转成 BufferedReader流
BufferedReader br = new BufferedReader(in1);
// //将第一步和第二布流合并，一步到位
// BufferedReader br = new BufferedReader(new InputStreamReader(
// new FileInputStream(filePath), "gbk"));
//读取
System.out.println("读取到的内容："+br.readLine());
//关闭流
br.close();
}
}
例2：编程将 字节流 FileOutputstream 包装成(转换成)字符流OutputStreamWriter对文件进行写入(按照gbk格式,可以指定其他，比如utf-8)
package transformation;
import java.io.*;
/**
* @author yeye
* @desc 使用OutputStreamReader写入文件
* 把字节流 FileOutputStream 转换成字符流 OutputStreamWriter
* 指定处理的编码格式，如UTF-8、GBK等
* @date 2024/8/22 17:09
*/
public class OutputStreamWriter01 {
public static void main(String[] args) throws IOException {
String filePath = "E:/aaa.txt";
String encoding = "UTF-8";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), encoding);
osw.write("你好，椰椰！");
osw.close();
System.out.println("写入文件成功！");
}
}
打印流——PrintStream和PrintWriter
PrintStream字节流，PrinteWriter字符流
打印流只有输出流，没有输入流。
例1：printStream 字节流打印
package printstream;
import java.io.IOException;
import java.io.PrintStream;
import static java.lang.System.out;
/**
* @author yeye
* @desc PrintStream (字节打印/输出流)
* @date 2024/8/22 17:30
*/
public class PrintStream01 {
public static void main(String[] args) throws IOException {
PrintStream ps = System.out;
//在默认的情况下，PrintStream 数据输出的位置是 默认输出，即显示器
ps.println("今天不想吃晚饭!");
//因为print底层调用的是write方法，所以可以直接使用write方法打印/输出
ps.write("。。。,".getBytes());
ps.close();
//也可以通过System.setOut()方法修改默认的输出位置
System.setOut(new PrintStream("E://test.txt"));
out.println("今天吃了晚饭!");
}
}
例2：PrinteWriter 字符流打印
package IOStream.printstream_;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @author yeye
* @desc PrinterWriter 的使用
* @date 2024/8/22 18:00
*/
public class PrintWriter01 {
public static void main(String[] args) throws IOException {
//标准输出，显示器
PrintWriter pw1 = new PrintWriter(System.out);
pw1.println("Hello World");
pw1.close();
//指定打印文件
PrintWriter pw2 = new PrintWriter(new FileWriter("E:/test.txt"));
pw2.println("Hello 明天");
pw2.close();
}
}
Properties类
unicode码查询：http://tool.chinaz.com/tools/unicode.aspx
- 专门用于读写配置文件的集合类
配置文件的格式：- 键=值
- 键=值
- 键值对不需要有空格，值不需要用 " " ，默认类型是String
- Properties父类是HashTable,底层就是Hashtable核心方法
- Properties 类常见的方法
- load：加载配置文件的键值对到Properties对象；
- list：将得到的键值对显示到指定设备/流对象；
- getProperty(key)：根据键获取对应的值；
- setProperty(key,value)：修改键对应的值，没有key,则添加；
- store：将Properties中的键值对存储到配置文件中，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码
如下一个配置文件 mysql.properties
ip = 1234
user = root
password = root
请问编程读取 ip 、user 和 pwd 的值是多少
例1：传统的方法
例2：使用Properties类可以方便实现
例1：传统方法：
配置文件：src/IOStream/mysql.properties
package IOStream.properties;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* @author yeye
* @desc
* @date 2024/8/22 18:25
*/
public class Properties01 {
public static void main(String[] args) throws IOException {
//读取mysql.properties文件，并得到ip,username,password
BufferedReader br = new BufferedReader(new FileReader("src/IOStream/mysql.properties"));
String line = null;
//循环读取
while((line = br.readLine()) != null){
//使用line变量调用split方法，以等号（=）作为分隔符来分割字符串。
//split方法将字符串分割成一个字符串数组split，其中包含两个元素：等号前的文本和等号后的文本。
String[] split = line.split("=");
System.out.println(split[0] + " 的值是" + split[1]);
//System.out.println(line);
}
br.close();
}
}
例2：使用Properties类完成对mysql.properties的读取
package IOStream.properties;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* @author yeye
* @desc
* @date 2024/8/22 19:08
*/
public class Properties02 {
public static void main(String[] args) throws IOException {
//使用Properties类完成对mysql.properties的读取
//第一步，创建Properties对象
Properties properties = new Properties();
//第二步，读取mysql.properties文件
properties.load(new FileReader("src/IOStream/mysql.properties"));
//第三步，把键值对显示到控制台
properties.list(System.out);
//第四步，根据键获取对应的值
String user = properties.getProperty("user");
String password = properties.getProperty("password");
System.out.println("用户名："+user);
System.out.println("密码："+password);
}
}
//运行结果
password=1234
encoding=UTF-8
user=root
用户名：root
密码：1234
例3：创建新的配置文件，并保存新的键值对
package IOStream.properties;
import java.io.*;
import java.util.Properties;
/**
* @author yeye
* @desc
* @date 2024/8/22 19:48
*/
public class Properties03 {
public static void main(String[] args) throws IOException {
//使用Properties类创建配置文件，并修改配置文件内容
Properties properties = new Properties();
//创建键值对
properties.setProperty("user","椰椰");//保存时，是中文的unicode编码
properties.setProperty("password","1234");
properties.setProperty("encoding","UTF-8");
//将键值对保存到配置文件中
properties.store(new FileOutputStream("src/IOStream/mysql02.properties"), "配置文件");
properties.list(System.out);
System.out.println("保存配置文件成功");
}
}
//运行结果
password=1234
encoding=UTF-8
user=椰椰
保存配置文件成功
//mysql02.properties文件中保存的内容
#\u914D\u7F6E\u6587\u4EF6
#Thu Aug 22 20:02:06 CST 2024
password=1234
encoding=UTF-8
user=\u6930\u6930