Java复习——File、IO流

---

Java文件

File类：用来描述硬盘上的文件或者文件夹，可通过传入文件的路径名构造文件对象

它的功能包括：
（1）创建功能：CreateNewFile()、mkdir()、mkdirs()
（2）删除功能：delete()
（3）重命名功能：renameTo(File dest)
（4）判断功能：isDirectory()、isFile()、exists()、isHidden()、canWrite()、canRead()
（5）基本获取功能：getPath()、getName()、getParent()
（6）高级获取功能：
String[] filename = file.list();//返回该路径表示目录中的文件名和目录名构成的字符串数组
File[] fileArray = file.listFiles();//返回该路径表示目录中的文件数组

---

Java异常

异常是程序中的一些错误，出现异常的原因包括：用户输入了非法数据；要打开的文件不存在；网络通信时连接中断，或者JVM内存溢出。

异常的类的层次如下：

Throwable类是Java中所有错误或异常的超类，只有当对象是此类或者其子类之一的实例时，才能通过throw语句抛出，该类的主要方法包括：

• getMessage()：返回异常信息字符串
• printStackTrace()：将异常的追踪信息输出至标准错误流。
• printStackTrance(PrintStream s)：将异常内容保存在日志文件中，以便查阅。
• toString()：返回异常类名和异常信息的描述字符串。

所有不是RuntimeException派生的Exception都是检查型异常，检查型异常需要进行处理，否则编译不通过。
对于运行时异常，JVM的默认处理方案为：把异常的类名，原因和位置等信息输出在控制台，然后终止程序，所以为了保证程序出错后依然可以正常推出，应该使用异常处理机制来处理。
（1）使用try…catch…finally

try{
    代码块
} catch(exception1){
  捕捉异常1，处理
} catch(exception2){
  捕捉异常2，处理
} catch(exception3){
  捕捉异常3，处理
}finally{
  无论是否发生异常，finally代码块总会被执行，除非在执行finally之前jvm退出
  通常用来释放资源、关闭文件、关闭数据库等。
}

final、finally、finalize有什么区别？

final可以修饰类、变量、方法，修饰的类不能被继承，修饰的变量不能重新赋值，修饰的方法不能被重写。finally用于抛异常，finally代码块无论是否发生异常，都会执行finally。
finalize是object类的一个方法，用于保证对象在垃圾回收之前完成特定资源的回收。

如果catch里面有return，finally还执行吗？如果执行，在return前还是后？

如果catch里面有return，finally还执行吗？如果执行，在return前还是后？
执行，在return之前执行。

（2）遇到无法处理的异常时：方法体内可以使用throw抛出这个异常，方法声明使用throws加异常类名表示可能有异常，然后调用这个方法的client进行异常处理。

Java IO流

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示像一个目标写数据。Java中用于操作流的对象都在java.io包中。

IO流分类：
（1）按照数据流向：输入流（读入数据）、输出流（写出数据）
（2）按照数据类型：字节流、字符流
IO流常用基类：
（1）字节流的抽象基类：InputStream、OutputStream
（2）字符流的抽象基类：Reader、Writer

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀，例如FileInputStream、FileReader等。

字节流写数据OutputStream

FileOutputStream，该类用来创建一个文件并向文件中写数据，构造方法如下： FileOutputStream(File file)、FileOutputStream(String name)
如果该流输出的目标文件不存在，那么该流会创造文件。

字节流写数据和进行其他操作的方式：
public void write(int b)：把指定字节写到输出流中
public void write(byte[] b)：把指定数组中存放的字节写到输出流中
public void close()：关闭此文件输出流，并释放与此流有关的所有系统资源

字节流读数据InputStream

FileInputStream：该类用于从文件读取数据，构造方法如下：
FileInputStream(File file)、FileInputStream(String name)

字节流读数据或进行其他操作的方式如下：
public int read(int r)：从输入流中读取指定字节的数据，返回整数值
public int read(byte[] r)：从输入流中读取数组长度的字节，返回读取的字节数
public int available()：返回下次从此输入流读取的字节数
public void close()：关闭此文件输入流，并释放与此流有关的所有系统资源

把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt。

import java.io.*;
public class HelloWorld {
	public static void main(String[] args){
		System.out.println("hello world");
		File a = new File("src/hello/a.txt");
		File b = new File("src/hello/b.txt");
		FileInputStream in = null;
		FileOutputStream out = null;
		try{
		in = new FileInputStream(a);
		out = new FileOutputStream(b,true);
		byte[] bt = new byte[8];
		while(in.read(bt) != -1){
			out.write(bt);
		}		}catch(IOException e){
			e.printStackTrace();
		}
		try {
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}
}

字节缓冲流

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，所以java提供了字节缓冲区流。

字节缓冲输出流：BufferedOutputStream，构造方法BufferedOutputStream(OutputStream o)
字节缓冲输入流：BufferedInputStream，构造方法BufferedInputStream(InputStream i)

因为字节缓冲流仅仅提供缓冲区，真正读写数据还得依靠基本的字节流对象进行操作，所有构造方法需要的是字节流，而不是具体的文件或者路径

字符流

字符输出流：OutputStreamWriter，该类是字符流通向字节流的桥梁，每次写数据时都会在给定编码上调用编码转换器，使用的字符集可显示给定.

构造方法如下：
public OutputStreamWriter(OutputStream out)：创建使用默认字符编码的 OutputStreamWriter。
public OutputStreamWriter(OutputStream out, String charsetName)：创建使用给定字符集的 OutputStreamWriter。

字符输入流：InputStreamReader，该类是字节流通向字符流的桥梁，每次读取字节时都会将其解码为字符.

构造方法如下：
public InputStreamReader(InputStream in)：创建使用默认字符集的InputStreamReader。
public InputStreamReader(InputStream in, String charsetName)：创建使用给定字符集的 InputStreamReader。

import java.io.*;
public class FileTest {
	public static void main(String[] args)throws IOException {
		File c = new File("src/hello/c.txt");
		FileOutputStream f = new FileOutputStream(c); 
		//参数指定编码
		OutputStreamWriter writer = new OutputStreamWriter(f,"GBK");
		//append方法：将字符添加到缓冲区
		writer.append("中文输入");
		writer.append("\r\n");
		writer.append("English");
		//关闭写入流，同时会把缓冲区内容写入文件
		writer.close();
		f.close();
		
		FileInputStream in = new FileInputStream(c);
		//编码应与写入相同
		InputStreamReader reader = new InputStreamReader(in,"GBK");
		StringBuffer sb = new StringBuffer();
		while(reader.ready()){
			sb.append((char)reader.read());
		}
		System.out.println(sb.toString());
		reader.close();
		in.close();
	}	
}

序列化流

序列化：为了让对象数据永久存储或者实现在网络种传输而生成的二进制流，让对象所属的类实现Seriable接口，就可以进行序列化。
反序列化：将序列化对象还原。

序列化代码

import java.io.Serializable;
public class Person implements Serializable{

	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	public Person(String name,int age){
		super();
		this.name = name;
		this.age = age;
	}
	public Person(){
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.IOException;

public class ObjectStream {
	public static void read() throws IOException, ClassNotFoundException{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/serialiable/a.txt"));
		Object obj = ois.readObject();
		ois.close();
		System.out.println(obj);
	}
	public static void write(Person p) throws FileNotFoundException, IOException{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/serialiable/a.txt"));
	    oos.writeObject(p);
	    oos.close();
	}
	public static void main(String[] args) throws IOException, ClassNotFoundException{
		Person p1 = new Person("zhang",23);
		write(p1);
		read();
	}
}

---

参考

https://github.com/DuGuQiuBai/Java/tree/master
菜鸟教程