FileOutputStream(String name): 通过文件路径创建文件字节输出流
FileOutputStream(File file): 通过File对象创建文件字节输出流
//根据构造方法传递的路径, 在磁盘上创建一个空文件 ("如果文件存在则会清空数据")
FileOutputStream fos=new FileOutputStream("模块名\\文件名"); // 1. 创建流对象
fos.write(); //写数据
fos.close(); //释放资源
//ASCII编码表: 1个byte就是一个字符 97 a
//GBK编码表: 2个byte数字组成一个汉字. "你": -60, -29
//UTF-8编码表: 3个byte数字组成一个汉字. "你": -28, -67, -96
FileOutputStream(String name, boolean append): 通过文件路径创建流, true可以续写
FileOutputStream(File file, boolean append): 通过File对象创建流, true可以续写
//换行:Windows系统: "\r\n" Linux系统: "\n" MacOS系统: "\r"
---------------------------------------------------------------------------------
//java.io.InputStream抽象类: 字节输入流 (顶层类)
FileInputStream(String name): 使用文件路径创建文件字节输入流
FileInputStream(File file):使用File对象创建文件字节输入流
int read(): 一次读一个字节. // 读到文件末尾返回-1 (返回int也是为了代码编写方便)
FileInputStream fis = new FileInputStream("模块名\\文件名"); //创建流对象
int len; //int 一个变量储存每次的数据
while((len=fis.read())!=-1){ //while循环读取
System.out.print((char)by); //文本中自带换行的byte
}
fis.close(); //释放资源
----------------------------------------------------------------------------------
FileInputStream fis = new FileInputStream("模块名\\文件名");
byte[] bytes = new byte[1024];
int len; // 定义int变量, 用于保存每次读取到的长度
while ((len = fis.read(bytes)) != -1) {
String s = new String(bytes, 0, len); //字符串转换 new String(数组名,起始索引,长度);
System.out.print(s); //输出到打印台
}
fis.close(); //释放资源
//复制粘贴同理
//先创建对象(FileInputStream)(FileOutputStream)
//while循环读取到内存 (fis.read())
//循环内将读取的数据写入硬盘(fos.write())
//释放资源
---------------------------------------------------------------------------------
//java.io.Reader抽象类: 字符输入流 (顶层)
FileReader(File file): 根据File对象创建文件字符输入流
FileReader(String fileName): 根据File对象创建文件字符输入流
FileReader fr = new FileReader("模块名\\文件名");
int ch; // 定义变量保存每次读到的字符
while ((ch = fr.read()) != -1) { //一次读一个字符char
System.out.print((char)ch); //不要换行
}
char[] cs = new char[1024]; // 一次读一个字符数组char[]
int len;
while ((len = fr.read(cs)) != -1) {
String s = new String(cs, 0, len); //// 读到多少个, 就转换多少个
System.out.print(s);
}
// 释放资源
fr.close();
-------------------------------------------------------------------------
//java.io.Writer抽象类: 字符输出流 (顶层类)
FileWriter(File file): 通过File对象创建文件字符输出流
FileWriter(String fileName): 通过文件路径创建文件字符输出流
//根据构造方法中的路径, 在磁盘上创建文件 ("如果文件已存在, 则清空文件内容")
FileWriter fw = new FileWriter("模块名\\文本名");
fw.write(97); // int ch 用int值代表char
fw.flush(); //flush(): 刷新缓冲区 (将数据从内存中写入到磁盘)
fw.close(); //close(): 刷新缓冲区, 并释放资源. 关闭流后不能再用同一个流对象操作
fw.write(byte[] bytes); //写一个字符数组
fw.write(bytes,起始索引,长度);
fw.write(String str): //写一个字符串
fw.write(str,起始索引,长度);
FileWriter(File file, boolean append): 通过File对象创建流. 第二个参数为true可以续写
FileWriter(String fileName, boolean append): 通过文件路径创建流. 第二个参数为true可以续写
//换行:windows: "\r\n" fw.write("\r\n");
//1. 如果不确定读写的是什么类型的数据, 用字节流最通用
//2. 如果确定读写的就是文本, 用字符流最方便
------------------------------------------------------------------------------------
//java.util.Properties类: 属性集, 属于Map的双列集合, 继承自Hashtable
void store(OutputStream out, String comments):集合用字节流写入文件(不能中文),并写入注释
void store(Writer writer, String comments):集合用字符流写入文件(可以中文), 并写入注释
Properties properties = new Properties(); // 创建Properties集合对象
FileWriter fw = new FileWriter("模块名\\文件名"); //创建字符输出流对象
properties.store(fw, null); //第二个参数注释穿null可行
fw.close(); //资源释放
void load(InputStream inStream):配置文件中通过字节流加载数据到Properties集合(不能读中文)
void load(Reader reader):配置文件中通过字符流加载数据到Properties集合(可以读中文)
Properties properties = new Properties(); //创建Properties集合对象
FileReader fr = new FileReader("模块名\\文件名"); // 创建文件字符输入流对象
properties.load(fr); // 方法调用完毕后, 集合里面就有键值对了
Set<String> strings = properties.stringPropertyNames();
for (String key : strings) {
// 通过键获取值
String value = properties.getProperty(key);
System.out.println(key + "=" + value);
}
Day10
//java.io.BufferedOutputStream类: 缓冲字节输出流
// 构造方法
BufferedOutputStream(OutputStream out): 使用基本流创建一个缓冲字节输出流
BufferedOutputStream(OutputStream out, int size): 使用基本流创建一个缓冲字节输出流, 设置缓冲区大小
BufferedOutputStream bos = // 创建缓冲流对象(基本流对象("模块名\\文本名))
new BufferedOutputStream(new FileOutputStream("模块名\\文本名"));
bos.write("你好".getBytes()); // 写入数据
// bos.flush(); // 可以省略
bos.close(); //资源释放
------------------------------------------------------------------------------------
//java.io.BufferedInputStream类: 缓冲字节输入流
BufferedInputStream(InputStream in): 使用基本流创建一个缓冲字节输入流
BufferedInputStream(InputStream in, int size):基本流创建一个缓冲字节输入流,设置缓冲区大小
BufferedInputStream bis =
new BufferedInputStream(newFileInputStream("模块名\\文本名"));
// 一次读一个字节数组
byte[] bytes = new byte[1024];
int len;
while ((len = bis.read(bytes)) != -1) {
// 打印字符串
System.out.println(new String(bytes, 0, len));
}
bis.close();
------------------------------------------------------------------------------------
//缓冲流的效率测试: 复制文件 缓冲流 + 一次读写一个字节数组 效率最高
缓冲字符输出流: BufferedWriterjava.io.BufferedWriter类:
// 构造方法
BufferedWriter(Writer out): 使用基本流创建一个缓冲字符输出流
BufferedWriter(Writer out, int size): 使用基本流创建一个缓冲字符输出流, 设置缓冲区大小
// 特有方法
void newLine(): 写入一个换行符, 换行符自动根据当前系统确定
BufferedWriter bw = // // 创建字符缓冲输出流对象
new BufferedWriter(new FileWriter("模块名\\文本名"));
for (int i = 0; i < 10; i++) { // 循环写入
bw.write("传智播客");
bw.newLine(); // 写入换行符
}
bw.close(); // 刷新并释放资源
--------------------------------------------------------------------------------
//java.io.BufferedReader类: 缓冲字符输入流
// 构造方法
BufferedReader(Reader in): 使用基本流创建一个缓冲字符输入流
BufferedReader(Reader in, int size): 使用基本流创建一个缓冲字符输入流, 设置缓冲区大小
// 特有方法
String readLine(): 一次读一行字符串, "不包含换行符". 读到文件末尾返回null
BufferedReader br = //创建缓冲字符输入流对象
new BufferedReader(new FileReader("模块名\\文本名"));
String line; // 定义一个字符串变量, 用于保存每次读到的一行字符串
while ((line = br.readLine()) != null) { // 循环读取
System.out.println(line); // 将读到的一行字符串打印到控制台
}
br.close();
-----------------------------------------------------------------------------------
转换流字符编码和字符集
编码: 字符 -> 字节 'a' -> 97
解码: 字节 -> 字符 97 -> 'a'
乱码问题: FileReader读取GBK编码
乱码原因: 读写编码不一致
//GBK文件中存储的是"你好"在GBK中对应的byte
而IDEA中使用FileReader读取文件时, 是将byte按照UTF-8编码表查找字符, 结果找不到, 就显示了问号
//java.io.OutputStreamWriter类: 输出转换流. 字符流通往字节流的桥梁
OutputStreamWriter(OutputStream out): 使用默认编码表创建转换流
OutputStreamWriter(OutputStream out, String charsetName): 使用指定编码表创建转换流
OutputStreamWriter o = //OutputStreamWriter(字节输出流,"编码表") UTF-8或GBK
new OutputStreamWriter(new FileOutputStream("a.txt"));
//java.io.InputStreamReader类: 输入转换流. 字节流通往字符流的桥梁
InputStreamReader(InputStream in): 使用默认编码表创建转换流
InputStreamReader(InputStream in, String charsetName): 使用指定编码表创建转换流
InputStreamReader r = //InputStreamReader((字节输出流,"编码表") UTF-8或GBK
new InputStreamReader(new FileInputStream("a.txt"));
---------------------------------------------------------------------------------
读取GBK编码文件, 转为UTF-8文件:
InputStreamReader isr = //创建输入转换流
new InputStreamReader(new FileInputStream("day10\\我是GBK文件.txt"),"GBK");
OutputStreamWriter osw = //创建输出转换流
new OutputStreamWriter(new FileOutputStream("day10\\我是UTF-8文件.txt"),"UTF-8");
int len;
while ((len=isr.read())!=-1){ //循环内读写
osw.write(len);
}
osw.close(); //释放资源
isr.close();
-----------------------------------------------------------------------------------
java.io.ObjectOutputStream类: 对象字节输出流
// 构造方法
ObjectOutputStream(OutputStream out)
// 特有成员方法
void writeObject(Object obj): 将对象写出
ObjectOutputStream oos = // 创建对象输出流
new ObjectOutputStream(new FileOutputStream("student.txt"));
Student s = new Student("小美女", 18); // 写对象
oos.writeObject(s);
oos.close(); //释放资源
------------------------------------------------------------------------------------
java.io.ObjectInputStream类: 对象字节输入流
// 构造方法
ObjectInputStream(InputStream in)
// 特有成员方法
Object readObject(): 读取对象
ObjectInputStream oos = //创建对象输入流
new ObjectInputStream(new FileInputStream("student.txt"));
Object o = oos.readObject(); // 读对象
Student s = (Student)o;
System.out.println(s);
oos.close(); // 释放资源
//serialVersionUID序列号的作用:
序列化操作时, 会根据类生成一个默认的 serialVersionUID 属性, 写入到文件中.
该版本号是根据类中成员计算出来的一个数值. 当类的成员发生改变时, 序列版本号也会发生变化
-----------------------------------------------------------------------------------
PrintStream特点:
1. 只有输出流, 没有输入流
2. PrintStream永远不会抛出IOException
3. 有特殊方法 print(), println(), 可以输出任意类型的值
//java.io.PrintStream类: 字节打印流
// 构造方法
PrintStream(File file): 创建字节打印流, 输出到一个文件
PrintStream(OutputStream out): 创建字节打印流, 输出到一个字节输出流
PrintStream(String fileName): 创建字节打印流, 输出到一个文件路径
//如果用 write() 方法, 会查编码表
//如果用 print(), println(), 则原样输出
PrintStream ps = new PrintStream("模块名\\文本名");
ps.write(97); //a
ps.println(97); //97
ps.print(97); //97
-----------------------------------------------------------------------------------
java.lang.System类:
// 静态方法
static void setOut(PrintStream out): 设置System.out的输出目的地为参数的打印流
System.out.println("在控制台输出");
PrintStream ps = new PrintStream("模块名\\文本名");
ps.write(97); //a
System.setOut(ps);
System.out.println("我在打印流目的地输出"); //输出值文本中
ps.close();
IO体系结构:
字节流
|_ InputStream # 字节输入流
| |_ FileInputStream # 专门操作文件的字节输入流
| |_ BufferedInputStream # 带有缓冲区的字节输入流, 效率高
| |_ ObjectInputStream # 对象输入流
|
|_ OutputStream # 字节输出流
|_ FileOutputStream # 专门操作文件的字节输出流
|_ BufferedOutputStream # 带有缓冲区的字节输出流, 效率高
|_ ObjectOutputStream # 对象输出流
|_ PrintStream # 字节打印流
字符流
|_ Reader # 字符输入流
| |_ BufferedReader # 带有缓冲区的字符输入流, 效率高
| |_ InputStreamReader # 将字节流转换为字符流输入的转换输入流
| |_ FileReader # 专门操作文件的字符输入流
|
|_ Writer # 字符输出流
|_ BufferedWriter # 带有缓冲区的字符输出流, 效率高
|_ OutputStreamWriter # 将字符流转换为字节流输出的转换输出流
| |_ FileWriter # 专门操作文件的字符输出流
收藏
淘帖
踩
