JAVA深入

JAVA深入第二章

本章学习要点：

• 输入输出

• 序列化与反序列化

输入输出

File类

方法
file.exists() 文件或者文件夹是否存在
file.mkdir()创建单个目录
file.mkdirs()创建多重目录
file.isDirectory() 文件是否为目录
file.isFile()是否为文件
file.createNewFile() 创建文件
file.delete()删除文件
“文件大小：”file.length()
“文件名:”file.getName()
“绝对路径:”file.getAbsolutePath()
“相对路径:”file.getPath()
“父相对路径:”file.getParent()
“父绝对路径:”file.getParentFile().getAbsolutePath()

流

流是指一连串流动的字符,是以先进先出方式发送信息的通道
Java流的分类

输入输出是相对的，是对于你内存来说的，把你内存中的数据写入文件叫输出，从文件中读取数据到内存叫输入

字节流是 8 位通用字节流，字符流是 16 位 Unicode 字符流
这些都是抽象类不能实例化。
文本文件的读写
用FileInputStream和FileOutputStream读写文本文件———-字节流 继承InputStream,OutputStream类
用BufferedReader和BufferedWriter读写文本文件———-字符流 继承Reader，Writer类

二进制文件的读写
使用DataInputStream和DataOutputStream读写二进制文件

用字节流读取文件
方法一：
1.创建输入流对象
FileInputStream fis=new FileInputStream(“book.txt”);
2.读取字节一个一个读取
int length=fis.read();
3.循环读取
while(length!=-1){
System.out.print((char)length);
length=fis.read();
}
fis.read 返回-1代表着数据读到最后了
4.关闭流
fis.close();
由于一个个字节读取效率过低 我们采用数组来读取
fis.available();返回剩余字节数
方法二：
1.创建输入流对象
FileInputStream fis=new FileInputStream(“book.txt”);
2.读取字节一个一个读取;
int length=0;
3.字节数组
byte[] by = new byte[20];
4.循环读取
while((length=fis.read(by))!=-1){
System.out.print(new String(by));
}
5. 关闭流
fis.close();

用字节流输出文件

1.创建输出流对象
FileOutputStream fos = new FileOutputStream(“temp/you.txt”);
2.写入
String string = “好好学习java!”;
// byte[],off偏移量,len字节大小;
// byte[] by = string.getBytes();
// fos.write(by, 3, by.length-3);
fos.write(string.getBytes(), 0, string.getBytes().length);第一个是字符转成字节，第二个是偏移量，第3个是字节长度
3.关闭流
fos.close();

用字节流输入并输出
1.创建输入流对象
FileInputStream fis = new FileInputStream(“temp/you.txt”);

2.创建输出流对象
FileOutputStream fos = new FileOutputStream(“temp/my.txt”);

3)中转站
byte[] by = new byte[1024];

int len = 0;
4.读取数据
while ((len = fis.read(by, 0, by.length)) != -1) {
5.写入数据
fos.write(by, 0, by.length);
}

6.关闭流
fos.close();
fis.close();
用字符流读取文件
1.创建读取对象
FileReader fr = new FileReader(“book.txt”);
2.创建缓存流对象
BufferedReader br= new BufferedReader(fr);
3.读取数据
String str=”“;
while((str=br.readLine())!=null){
System.out.println(str);
}
br.readLine()一行一行读取返回字符串
4.关闭缓存流
br.close();

用字符流写入文件
1.创建写入对象
FileWriter fw=new FileWriter(“temp/buffer.txt”);
2.创建缓存流对象
BufferedWriter bw= new BufferedWriter(fw);
3.写入数据
bw.write(str);

4.关闭缓存流
bw.close();
fw.close();

用字符流读取并写入文件
1)字符流对象
FileReader fr = new FileReader(“book.txt”);
FileWriter fw=new FileWriter(“temp/buffer.txt”);

2)缓存流对象
通过字符流的方式读取文件，并使用缓冲区，提高读文本文件的效率
BufferedReader br= new BufferedReader(fr);
BufferedWriter bw= new BufferedWriter(fw);
String str=”“;
while((str=br.readLine())!=null){
bw.write(str+”\r\n”);
}

4)关闭缓存流
br.close();
bw.flush(); //清空缓冲区
bw.close();

字节流转换为字符流读取
1. 创建输入流对象
FileInputStream fis = new FileInputStream(“temp/you.txt”);
2.创建输出流对象
FileOutputStream fos = new FileOutputStream(“temp/boby.txt”);
3.字节流读对象 utf-8字符编码;将字节流转化为字符流
InputStreamReader isr = new InputStreamReader(fis,”utf-8”);
OutputStreamWriter osr = new OutputStreamWriter(fos,”utf-8”);
缓冲流
BufferedReader br = new BufferedReader(isr);
BufferedWriter bw = new BufferedWriter(osr);

String str = “”;
while ((str = br.readLine()) != null) {
bw.write(str + “\r\n”);
}
4.关闭流
bw.flush();
bw.close();
br.close();

序列化与反序列化

序列化是将对象的状态存储到特定存储介质中的过程
反序列化则是从特定存储介质中的数据重新构建对象的过程
序列化
1.实例化对象
Student zj = new Student(“张杰”, 20,”杭州西湖”);
Student qly = new Student(“钱利阳”, 21,”杭州西湖”);
//集合对象
List list = new ArrayList();
list.add(zj);
list.add(qly);
2.创建输出流对象
FileOutputStream fis=new FileOutputStream(“student.bin”)
3.创建二进制对象
ObjectOutputStream oos = new ObjectOutputStream（fis）
4.写入
oos.writeObject(list);
5.关闭
fis.close;
oos.close;

反序列化
1.创建输入流对象
FileInputStream fis =new FileInputStream(“student.bin”);
2.创建二进制对象
ObjectInputStream ois = new ObjectInputStream(fis);
3.读取
先将其转化为对象
List student = (List) ois.readObject();
for (Student student2 : student) {
System.out.println(student2);
}
4.关闭
fis.close;
ois.close;