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);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
