Core Java第十四章知识点总结——文件与I/O流
Core Java第十四章知识点总结——文件与I/O流
知识点预览
File类的使用
IO的分类
字节流
字符流
对象序列化
File类
1. java.io.File类
代表硬盘上的一个文件或者文件夹
文件、文件夹
代表：只是开辟内存空间，有File对象不一定有对应的文件或者文件夹
2. java中文件路径的表示形式
a) windows中表示 c:\suns.txt
b) java中表示 c:\\suns.txt c:/sun.txt
3. File类的构造方法
构造方法 File类没有无参构造方法
File(String pathname)
File(String parent,Stirngchild)
//parent：父目录
//child：
File(File parent,String child)
4. File类的常用方法
a) createNewFile() 创建文件，文件不存在才创建
b) mkdir/mkdirs() 创建目录 mkdir创建一级目录 mkdirs 创建多级目录
c) delete() 执行完后立即删除
d) deleteOnExit() 当程序退出时才删除
e) exists() 当前文件或者目录是否存在 返回值 boolean
f) isFile() 返回值 boolean
g) isDirectory返回值 boolean
h) getPath() 文件路径
i) getName() 文件名
j) getParent() 父目录
k) getAbsolutePath() 绝对路径
l) list() 1级目录才可调用（子目录、文件）子目录有子目录，不能获得
I/O
1.I/O流概念
Input/Output针对于JVM内存
2. 流的概念
用来传输数据的对象 生活中比如电线、水管
3. I/O流的分类
按流向（针对Java虚拟机）输入流输出流
按数据单位 字节流（可传输任意文件）字符流（处理文本文件）
按功能 节点流（真正完成传输）过滤流（用于增加节点流的功能）
字节流
1.字节流的概念
传输的数据单位是字节，也意味着字节流能够处理任何一种文件
2. 字节流的组成
InputStream OutputStream （所有字节流的父类 抽象类不能创建对象）
3.FileInputStream字节输入流
a) FileInputStream构造方法
i. FileInputStream（String filename）
ii. FileInputStream(File file)
b)read方法
i. int read();//读取字节
ii. int read(byte[] bs);//读取后填充数组 返回实际读取数
iii. int read(byte[] bs,int off,intlen);
package chp14.ex02;
import java.io.FileInputStream;
import java.io.InputStream;
/**
*
* @Author: Wentasy
* @FullName: TestInputStream.java
* @Description: FileInputStream 去读内容
* @Create Date: 2012-8-18
*/
public class TestInputStream {
public static void main(String args[])throws Exception{
InputStream is = new FileInputStream("oracle.txt");
int len = 0;
while((len=is.read())!=-1){
char c = (char)len;
System.out.println(c);
}
}
}
package chp14.ex03;
import java.io.FileInputStream;
import java.io.InputStream;
/**
*
* @Author: Wentasy
* @FullName: TestInputStream.java
* @Description: FileInputStream read byte数组
* @Create Date: 2012-8-18
*/
public class TestInputStream{
public static void main(String args[]) throws Exception{
InputStream fin = new FileInputStream("oracle.txt");
byte[] bs = new byte[6];
int len = 0;
while( (len=fin.read(bs))!=-1){
//注意使用读取的实际长度
for(int i = 0; i< len; i++){
System.out.print((char)bs[i]);
}
System.out.println();
}
fin.close();
}
}
c) close()//关闭资源
d) 小技巧
同步执行的代码------->放入while循环中
4.FileOutputStream 字节输出流（JVM------->文件）
a) FileOutputStream构造方法
i. FileOutputStream(String path);
ii. FileOutputStream(File file);
b) write方法
i. void write(int v);//输出一个字节
ii. void write(byte[] bs);//输出byte数组内容
iii. int write (byte[] bs,int off,int len);//输出部分
c) close方法
d) 追加方式
i. FileOutputStream(String path,boolean append);
ii. FileOutputStream(File file,boolean append);
package chp14.ex05;
import java.io.*;
/**
*
* @Author: Wentasy
* @FullName: TestOutputStream.java
* @Description: FileOutputStream 追加写入内容
* @Create Date: 2012-8-18
*/
public class TestOutputStream{
public static void main(String args[]) throws Exception{
String hello = "Hello World";
byte[] bs = hello.getBytes();
FileOutputStream fout=
new FileOutputStream("test.txt",true);
fout.write(bs);
fout.close();
}
}
iii. append：为true表示追加 为false 更新后创建
5. 异常处理
try…catch…finally
finally：书写关闭资源的代码
package chp14.ex06;
import java.io.*;
/**
*
* @Author: Wentasy
* @FullName: TestInputStream.java
* @Description: 文件读写的异常处理
* @Create Date: 2012-8-18
*/
public class TestInputStream {
public static void main(String args[]) {
FileInputStream fin = null;
try {
fin = new FileInputStream("abc.txt");
byte[] bs = new byte[6];
int len = 0;
while ((len = fin.read(bs)) != -1) {
for (int i = 0; i < len; i++) {
System.out.print((char) bs[i]);
}
System.out.println();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
//判断是否为空
if (fin != null){
try {
fin.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6. 过滤流
a) Data Stream
DataInputStream
readXXX();
DataOutputStream
writeXXX();
对八种基本数据类型和String的支持
package chp14.ex07;
import java.io.*;
/**
*
* @Author: Wentasy
* @FullName: TestDataStream.java
* @Description: DataStream过滤流的使用
* @Create Date: 2012-8-18
*/
public class TestDataStream{
public static void main(String args[]) throws Exception{
//创建节点流
FileOutputStream fout = new FileOutputStream("pi.dat");
//封装过滤流
DataOutputStream dout = new DataOutputStream(fout);
//写数据
dout.writeDouble(3.14);
//关闭外层流
dout.close();
//创建节点流
FileInputStream fin= new FileInputStream ("pi.dat");
//封装过滤流
DataInputStream din = new DataInputStream(fin);
//读数据
double pi = din.readDouble();
//关闭外层流
din.close();
System.out.println(pi);
}
}
b) 过滤流的开发步骤
i. 创建节点流
ii. 基于节点流创建过滤流
iii. 读/写数据
iv. 关闭外层流（过滤流）
过滤流不能连接JVM和数据源 真正起作用的还是节点流
c) Buffered Stream
BufferedInputStream
BufferedOutputStream
增加了缓冲区功能------->提高程序执行效率
注释bout.close();//不会写任何内容到文件
bout.flush();//让缓冲区的内容同步到外部文件中
package chp14.ex08;
import java.io.*;
/**
*
* @Author: Wentasy
* @FullName: TestBufferedStream.java
* @Description: BufferedStream 过滤流的使用
* @Create Date: 2012-8-18
*/
public class TestBufferedStream{
public static void main(String args[]) throws Exception{
String data = "Hello World";
byte[] bs = data.getBytes();
//创建节点流
FileOutputStream fout = new FileOutputStream("test.txt");
//封装过滤流
BufferedOutputStream bout = new BufferedOutputStream(fout);
//写数据
bout.write(bs);
//关闭外层流
bout.close();
//一定要关闭或者flush
//bout.flush();
}
}
d)Object Stream
ObjectInputStream
ObjectOutputStream
ObjectStream特点：
增加了缓冲区功能
增强了8种基本数据类型的处理
增强了读写对象的功能
writeObject();
readObject();
对象序列化详见最后一节 对象序列化
字符流
1. 字符编码
字符或者文字转换成数字，即称为编码
数字转换成字符或者文字，即称为解码
2.常见的编码规范
a) ASCII：英文、英文标点
b) ISO-8859-1：西欧文字、标点 如德文、法文
c) GBK：大陆
d) UTF-8：国际通用
e) 补充：big5：大五码 繁体字台湾使用
3. 乱码问题
a) 编码方式不一致 导致乱码
b) 任意一种编码都兼容ASCII，所以英文不可能出现乱码
4. 字符流的组成
Reader
Writer
5. FileReader
FileReader(StringfuleName)
close()
int read(char[]cbuf)
6. FileWriter
FileWriter(String fuleName)
close()
write(Stringvalue)
缺点：FileReader、FielWriter不能更改编码方式
7. InputStreamReader和OutputStreamWriter
a) 特点
可以把一个字节流转换成一个字符流（桥转换）
在转换时可以执行编码方式
b) InputStreamReader
InputStreamReader(InputStream is)
InputStreamReader(InputStream is,String charSet)
int read(char[] cbuf)
package chp14.ex12;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
*
* @Author: Wentasy
* @FullName: TestInputStreamReader.java
* @Description: InputStreamReader类的使用
* @Create Date: 2012-8-18
*/
public class TestInputStreamReader {
public static void main(String args[]) throws Exception{
InputStream is = new FileInputStream("oracle.txt");
InputStreamReader ir = new InputStreamReader(is);
char[] value = new char[1024];
int len = 0;
while((len=ir.read(value))!=-1){
for(int i=0;i<len;i++){
char c = value[i];
System.out.print(c);
}
System.out.println();
}
}
}
c) OutputStreamReader
OutputStreamReader(OutputStream os)
OutputStreamReader(OutputStream os, String charSet)
write(Stringvalue)
8. 字符流过滤流
a) BufferedReader
i. 字符过滤流
ii. 提供了缓冲功能
iii. 可以一行一行的读取内容 public String readLine();
package chp14.ex13;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
*
* @Author: Wentasy
* @FullName: TestBufferedReader.java
* @Description: BufferedReader 的使用
* @Create Date: 2012-8-18
*/
public class TestBufferedReader {
public static void main(String args[])throws Exception{
InputStream is = new FileInputStream("oracle.txt");
InputStreamReader ir = new InputStreamReader(is);
BufferedReader br = new BufferedReader(ir);
String value = null;
while((value=br.readLine())!=null){
System.out.println(value);
}
}
}
b) 完整的字符输入流的开发步骤
i. 创建节点流
ii. 桥转换为字符流
iii. 在字符流的基础上封装过滤流
iv. 读/写数据
v. 关闭外层流
c) PrintWriter
i. 字符过滤流
ii. 封装了缓冲功能
iii. 可以一行一行的输出内容 println();
iv. 第一种用法（字符流
package chp14.ex14;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
/**
*
* @Author: Wentasy
* @FullName: TestPrintWriter.java
* @Description: PrintWriter的第一种使用方式
* @Create Date: 2012-8-18
*/
public class TestPrintWriter {
public static void main(String args[]) throws Exception{
OutputStream os = new FileOutputStream("oracle.txt",true);
OutputStreamWriter ow = new OutputStreamWriter(os);
PrintWriter out = new PrintWriter(ow);//常规使用
out.println("suns");
out.flush();
out.close();
}
}
v. 第二种用法（字节流） PrintWriter也有桥转换功能
package chp14.ex15;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
/**
*
* @Author: Wentasy
* @FullName: TestPrintWriter.java
* @Description: PrintWriter的第二种使用方式
* @Create Date: 2012-8-18
*/
public class TestPrintWriter {
public static void main(String args[])throws Exception{
OutputStream is = new FileOutputStream("sun1.txt");
//直接传入字节输出流 PrintWriter实现桥转换成字符流 再转换成过滤流
PrintWriter out = new PrintWriter(is);
out.println("hello test");
out.flush();
out.close();
}
}
对象序列化
1.对象序列化
对象放在流上进行传输
2.可序列化
对象可以在流上进行传输 即称该对象可序列化
3.java.io.Serializable接口
a) 对象可序列化，需要实现该接口
b) 没有方法需要实现，仅仅是标识性接口通过网络传输
c) 小技巧：
一般double、int、对象等，存储在dat文件中
4.transient关键字
修饰属性，将不参与序列化
5.序列化时注意事项
a) 不要使用追加的方式书写对象
b) 如果一个对象的属性又是一个对象，则要求这个属性对象也实现了Serializable接口。
package chp14.ex09;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
//实现序列化接口
class Student implements Serializable{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
/**
*
* @Author: Wentasy
* @FullName: TestSerializable.java
* @Description: ObjectInputStream ObjectOutputStream 读写对象
* @Create Date: 2012-8-18
*/
public class TestSerializable {
public static void main(String[] args) throws Exception {
Student stu1 = new Student("tom", 18);
Student stu2 = new Student("jerry", 18);
FileOutputStream fout = new FileOutputStream("stu.dat");
ObjectOutputStream oout = new ObjectOutputStream(fout);
oout.writeObject(stu1);
oout.writeObject(stu2);
oout.close();
FileInputStream fin = new FileInputStream("stu.dat");
ObjectInputStream oin = new ObjectInputStream(fin);
Student s1 = (Student) oin.readObject();
Student s2 = (Student) oin.readObject();
oin.close();
System.out.println(s1.name + " " + s1.age);
System.out.println(s2.name + " " + s2.age);
}
}