目录
IO流
i：input 输入(读取)
o：output 输出(写入)
流：数据(字符，字节)1个字符=2个字节 1个字节=8个二进制位
最顶级的父类
字节流
字节输出流【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) ：将指定的字节输出流
java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件
作用：把内部中的数据写入硬盘的文件中
构造方法：
public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件
public FileOutputStream(String name) ： 创建文件输出流以指定的名称写入文件
参数： 写入数据的目的
String name：目的地是一个文件的路径
File file：目的地是一个文件
作用：
1.创建一个FileOutputStrem对象
2.会根据构造方法中传递的文件/文件路径，创建一个空的文件
3.会把FileOutputStream对象指向创建好的文件
字节输出流写入数据到文件
写入数据的原理(内存-->硬盘)
java->JVM->OS->OS调用写数据的方法->把数据写到文件中
字节输出流的使用步骤(重点)：
1.创建一个FileOutputStream对象，构造方法中传递写入数据的目的地
2.调用FileOutputStream对象中的方法write，把数据写入到文件中
3.释放资源(流使用会占用一定的空间，使用完毕要把内存清空，提供程序的效率)
代码：
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一次写入多个字节的方法：
public void write(byte[] b) ：将 b.length字节从指定的字节数组写入此输出流
如果写的第一个字节是整数(0~127)，那么显示的时候会查询ASCII表
如果写的第一个字节是负数，那么第一个字节回合第二个字节，两个字节组成一个中文显示，查询系统默认码表(GBK)
public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流
八字节数组的一部分写入到文件中
int off：数据的开始索引
int len：写几个字节
代码：
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();
}
}
输出结果：
黑马程序员write(byte[] b, int off, int 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();
}
}
输出结果：
cdps. 写入字符串的方法：可以使用String类中的方法把字符串，转换为字节数组
byte[ ] getBytes( ) 把字符串转换为字节数组
字节输出流的续写和换行
追加写/续写：使用两个参数的构造方法
public FileOutputStream(File file, boolean append) ： 创建文件输出流以写入由指定的 File对象表示的文件
public FileOutputStream(String name, boolean append) ： 创建文件输出流以指定的名称写入文件
参数：
String name：写入数据的目的地
boolean append：追加写开关
true：创建对象不会覆盖源文件，继续在文件的末尾追加写数据
flase：创建一个新文件，覆盖源文件
写换行：符号：
windows：\r\n
linux：/n
mac：/r
字节输入流【InputStream】
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源
public abstract int read() ： 从输入流读取数据的下一个字节，读取到文件的末尾返回-1
public int read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中
FileInputStream extends InputStream(文件输入流)
作用：把硬盘文件中的数据，读取到内存中使用
构造方法：
FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名
FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名
参数：读取文件的数据源
String name：文件的路径
File file：文件
构造方法的作用：
1.会创建一个FileInputStream对象
2.会把FileInputStream对象指定构造方法中要读取的文件
字节输入流读数据的原理(硬盘->内存)
java->JVM->OS->OS读取数据的方法->读取文件
字节输入流的使用步骤(重点)
1.创建一个FileInputStream对象，构造方法中绑定要读取的数据源
2.使用FileInputStream对象中的方法read，读取文件
3.释放资源
ps！！！ 布尔表达式( len= fis.read(b))!=‐1
1.fis.read()： 读取一个字节
2.len = fis.read() ： 把读取到的字节赋值个遍历len
3.( len= fis.read(b))!=‐1：判断遍历len是否不等于-1
字节输入流一次读取多个字节的方法：
int read(byte[ ] b) 从输入流中读取一定数量的字节，并将其存储到缓冲区数组b中
明确两件事情：
1.方法的参数byte[ ] 的作用
起到缓冲作用，存储每次读取到的多个字节
数组的长度一般定义为1024(1kb)或者1024的整数倍
2.方法的返回值int是什么
每次读取的有效字节个数
String类的构造方法
String(byte[ ] bytes) 把字节数组转换为字符串
String(byte[ ] bytes，int offset，int length) 把字节数组的一部分转换为字符串 offset：数组的开始索引 length：转换的字节个数
字符流
使用字节流读取中文的问题
1个中文
GBK:占用两个字节
UTF-8:占用三个字节
java.io.Reader：字符输入流，是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
共性的成员方法：
public void close() ：关闭此流并释放与此流相关联的任何系统资源
public int read() ： 从输入流读取一个字符
public int read(char[ ] cbuf) ： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中
java.io.FileReader extends InputStreamReader extends Reader
FileReader：文件字符输入流
作用：把硬盘文件中的数据以字符的方式读取到内存中
构造方法：
FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象
FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称
FileReader构造方法的作用：
1.创建一个FileReader对象
2.会把FileReader对象指向要读取的文件
字符输入流读取字符数据
字符输入流的使用步骤：
1.创建FileReader对象，构造方法中绑定要读取的数据源
2.使用FileReader对象中的方法read读取文件
3.释放资源
String类的构造方法：
String(char[ ] value) 把字符数组转为字符串
String(char[ ] value，int offset， int count) 把字符数组的一部分转换为字符串 offset数组的开始索引 count转化的个数
代码：
字符
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();
}
}
输出结果：
黑
马
程
序
员字符数组
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();
}
}
输出结果：
黑马
程序
员字符输出流Writer类&FileWriter类
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() 关闭此流，但要先刷新它
java.io.FileWriter extends OutputStreamWriter extend Writer
FileWriter：文件字符输出流
作用：把内存中字符数据写入到文件中
构造方法：
FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象
FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称
参数：写入数据的目的地
String fileName：文件的路径
File file：是一个文件
构造方法的作用：
1.会创建一个FileWriter对象
2.会根据构造方法中传递的文件/文件的路径，创建文件
3.会把FileWriter对象指向创建好的文件
字符输出流的使用步骤(重点)
1.创建FileWriter对象
2.使用FileWriter中的方法write，把数据写入到内存缓冲区中(字符转换为字节的过程)
3.使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中
4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
代码：
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田flush方法和close方法
flush方法和close方法的区别
flush ：刷新缓冲区，流对象可以继续使用。
close :先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了
字符输出流写数据的其他方法
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写的字符个数
字符输出流的续写和换行
续写/追加写：使用两个参数的构造方法
FileWriter(String fileName，boolean append)
FileWriter(File file，boolean append)
参数：
String fileName，File file：写入数据的目的地
boolean append：续写开光 true：不会创建新的文件覆盖源文件，可以续写；false：创建新的文件覆盖源文件
换行：换行符号
windows：\r\n
linux：/n
mac：/r
IO异常处理
在jdk1.7之前使用try catch finally 处理流中的异常
try{
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}finally{
一定会指定的代码
资源释放
}
JDK7的新特性
在try的后边可以增加一个()，在括号中可以定义流对象
那么这个流对象的作用域就在tey中有效
try中的代码执行完毕，会自动把流对象释放，不用写finally
格式：
try(定义的流对象；定义的流对象...){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
JDK9的新特性
在try的前面可以定义流对象
在try的后边( )中可以直接引入流对象的名称(变量名)
在try代码执行完毕之后，流对象也可以释放掉，不用写finally
格式：
A a = new A( )；
B b = new B( );
try(a,b){
可能会产生异常的代码
}catch(异常类变量 变量名){
异常的处理逻辑
}
属性集
java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>
Properties类表示了一个持久的属性集。Properties可保存在流中或者从流中加载
Properties集合是一个唯一和IO流相结合的集合
可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
可以使用Properties集合中的方法load，把硬盘中保存的文件(键值对)，读取到集合中使用
属性列表每一个键及气对应值都是一个字符串
Properties集合是一个双列集合，key和value默认都是字符串
Properties集合有一些操作字符串的特有方法
public Object setProperty(String key, String value) 调用Hashtable的方法put 保存一对属性
public String getProperty(String key) 通过key找到value之，此方法相当于Map集合中的get(key) 使用此属性列表中指定的键搜索属性值
public Set<String> stringPropertyNames() 返回此属性列表中的键集，其中改建机器对应值是字符串，此方法相当于Map集合中的keySet方法 所有键的名称的集合
代码：
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.txt
209385038
D:\a.txt
filename ‐‐ a.txt
length ‐‐ 209385038
location ‐‐ D:\a.txtProperties集合中的方法store
可以使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
void store(OutputStream out， String comments)
void store(Writer writer， String comments)
参数：
OutputStream out：字节输出流，不能写入中文
Writer writer：字符输出流，可以写中文
String comments：注释，用来结束说明保存的文件是做什么用的
不能使用中文，会产生乱码，默认是Unicode编码 一般使用" "空字符串
使用步骤：
1.创建Properties集合对象，添加数据
2.创建字节输出流/字符输出流对象，构造方法中绑定要输出的目的地
3.使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
4.释放资源
Properties集合中的方法load
可以使用Properties集合中的方法load，把硬盘中保存的文件(键值对)，读取到集合中使用
void load(InputStream inStream)
void load(Reader reader)
参数：
InputStream inStream：字节输入流，不能读取含有中文的键值对
Reader reader：字符输入流，能读取含有中文的键值对
使用步骤：
1.创建Properties集合对象
2.使用Properties集合对象中的方法load读取保存键值对的文件
3.遍历Properties集合
注意：
1.存储键值对的文件中，键与值默认的连接符号可以使用=，空格(其他符号)
2.存储键值对的文件中，可以使用#进行注释，被注释的键值对不会再被读取
3.存储键值对的文件中，键与值默认都是字符串，不用再加引号
2204
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
