Oracle培训（十四）——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);
		
	}
}