学习记录分享（IO框架）

3.（流的分类）对于FileInputStream来说，从方向上来分，它是（输入流），从数据单位上分，它是（字节流），从功能上分，它是（字节节点流）。
4.（字节流）FileInputStream有三个重载read方法，其中：
Ⅰ.无参的read方法返回值为（int）类型，表示（实际读到的字节所对应的十进制数值）。
Ⅱ.int read(byte[] bs)方法返回值表示（读取到的有效字符个数），参数表示（读取到的字节放入bs数组中）。
Ⅲ.int read(byte[] bs,int offset,int len)方法返回值表示（读取到的有效字符个数），参数分别表示（数组bs），（读取到的第一个字节放入数组的下标位置），（长度）。
5.（字节流）下面关于FileInputStream类型的说法正确的是：AB
A. 创建FileInputStream对象是为读取硬盘上的文件
B. 创建FileInputStream对象时，如果硬盘上对应的文件不存在，则抛出一个异常
C. 利用FileInputStream对象可以创建文件
D. FileInputStream对象读取文件时，只能读取文本文件
6. （字节流）填空：
Ⅰ. 创建FileOutputStream对象时，如果对应的文件在硬盘上不存在，则会（自动创建）；如果对应的文件在硬盘上已经存在，则（覆盖原文件）；
Ⅱ. 如果使用FileOutputStream（String path，boolean append）构造方法创建FileOutputStream对象，并给定第二个参数为true，则效果为（将字节写入文件末尾处，而不是写入文件开始处（追加））。创建FileOutputStream时（会）（会|不会）产生异常。
7.代码改错

修改如下：

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class TestFileInputStream {

	public static void main(String[] args) throws FileNotFoundException {
		FileInputStream fin = new FileInputStream("Files\\test.txt");// FileNotFoundException需声明异常
		try {
			System.out.println(fin.read());
		} catch (Exception e) {

		}

	}

}

8.（字节流）利用FileInputStream和FileOutputStream，完成下面的要求：
Ⅰ. 用FileOutputStream在当前目录下创建一个文件“test.txt”，并向文件输出“Hello World”，如果文件已经存在，则在原有文件内容后面追加。
Ⅱ. 用FileInputStream读入test.txt文件，并在控制台上打印出test.txt中的内容。
Ⅲ. 要求用try-catch-finally处理异常，并且关闭应放在finally块中。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test08 {

	public static void main(String[] args) throws IOException {

		// 指定位置创建字节输出流对象，true代表如哦存在此文件，在其内容后面追加
		FileOutputStream fos = new FileOutputStream("E:\\qianfengjava\\day31\\test.txt");
		String s = "Hello World";
		byte[] b = s.getBytes();// 将字符串转换为字符数组
		fos.write(b);// 写入

		// 创建字节输入流对象，并读入指定的文件路径
		FileInputStream fis = new FileInputStream("E:\\qianfengjava\\day31\\test.txt");
		byte[] b2 = new byte[2];
		while (true) {
			int count = fis.read(b2);
			if (count == -1) {
				break;
			}
			for (int i = 0; i < count; i++) {
				System.out.print((char) b2[i]);
			}
		}
		fis.close();
		fos.close();
	}
}

运行结果：

Ⅲ

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test08 {

	public static void main(String[] args) {

		// 指定位置创建字节输出流对象，true代表如哦存在此文件，在其内容后面追加
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("E:\\qianfengjava\\day31\\test.txt");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		String s = "Hello World";
		byte[] b = s.getBytes();// 将字符串转换为字符数组
		try {
			fos.write(b);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} // 写入

		// 创建字节输入流对象，并读入指定的文件路径
		FileInputStream fis = null;
		try {
			fis = new FileInputStream("E:\\qianfengjava\\day31\\test.txt");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			byte[] b2 = new byte[2];
			int count = 0;
			while (true) {
				try {
					count = fis.read(b2);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();

				} finally {
					if (count == -1) {
						break;
					}
					for (int i = 0; i < count; i++) {
						System.out.print((char) b2[i]);
					}
				}

			}
		} finally {
			try {
				fis.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				fos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}
}

13.（对象序列化）
为了让某对象能够被序列化，要求其实现（Serializable）接口；
为了该对象某个属性不参与序列化，应当使用（transient）修饰符。
15.（对象序列化）
在PrintWriter中，有一个方法print（Object obj）
在ObjectOutputStream中，有一个方法writeObject（Object obj）
请简述这两个方法的区别？
print（Object obj）是obj先执行toString方法，然后打印输出
writeObject（Object obj）是将obj对象序列化，写入到文件里以数据的形式存储
16.（对象序列化）有以下代码



A
修改后如下：

import java.io.*;

public class TestSerializable {

	public static void main(String[] args) throws IOException {
		Address addr = new Address("Beijing", "100000");
		Worker w = new Worker("Tom", 18, addr);
		OutputStream os = new FileOutputStream("fout.dat");
		ObjectOutputStream oout = new ObjectOutputStream(os);
		oout.writeObject(w);
		oout.close();

	}

}

class Address implements Serializable {
	private String addressName;
	private String zipCode;

	public Address(String addressName, String zipCode) {
		super();
		this.addressName = addressName;
		this.zipCode = zipCode;
	}

	public String getAddressName() {
		return addressName;
	}

	public void setAddressName(String addressName) {
		this.addressName = addressName;
	}

	public String getZipCode() {
		return zipCode;
	}

	public void setZipCode(String zipCode) {
		this.zipCode = zipCode;
	}

}

class Worker implements Serializable {
	private String name;
	private int age;
	private Address address;

	public Worker(String name, int age, Address address) {
		super();
		this.name = name;
		this.age = age;
		this.address = address;
	}

	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;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

}