1. Java中有几种类型的流
按照流的方向：输入流（inputStream）和输出流（outputStream）。
按照实现功能分：节点流（可以从或向一个特定的地方（节点）读写数据。如 FileReader）和处理流（是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。）
按照处理数据的单位：字节流和字符流。字节流继承于 InputStream 和 OutputStream，字符流继承于InputStreamReader 和OutputStreamWriter。
2. 字节流如何转为字符流
字节输入流转字符输入流通过InputStreamReader实现，该类的构造函数可以传入InputStream对象。
字节输出流转字符输出流通过OutputStreamWriter实现，该类的构造函数可以传入OutputStream对象。
3. 如何将一个java对象序列化到文件里
在java中能够被序列化的类必须先实现Serializable接口，该接口没有任何抽象方法只是起到一个标记作用。
1. //对象输出流
2. ObjectOutputStream objectOutputStream =
3. new ObjectOutputStream(new FileOutputStream(new File("D://obj")));
4. objectOutputStream.writeObject(new User("zhangsan", 100));
5. objectOutputStream.close();
6. //对象输入流
7. ObjectInputStream objectInputStream =
8. new ObjectInputStream(new FileInputStream(new File("D://obj")));
9. User user = (User)objectInputStream.readObject();
10. System.out.println(user);
11. objectInputStream.close();
4. 字节流和字符流的区别（2017-11-23-wzz）
字节流读取的时候，读到一个字节就返回一个字节； 字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编码表，将查到的字符返回。 字节流可以处理所有类型数据，如：图片，MP3，AVI 视频文件，而字符流只能处理字符数据。只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。字节流主要是操作byte类型数据，以byte数组为准，主要操作类就是OutputStream、InputStream
字符流处理的单元为2个字节的Unicode字符，分别操作字符、字符数组或字符串，而字节流处理单元为1个字节，操作字节和字节数组。所以字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的，所以它对多国语言支持性比较好！如果是音频文件、图片、歌曲，就用字节流好点，如果是关系到中文（文本）的，用字符流好点。在程序中一个字符等于两个字节，java提供了Reader、Writer两个专门操作字符流的类。
5. 如何实现对象克隆？
有两种方式。
1). 实现 Cloneable 接口并重写 Object 类中的 clone()方法；
2). 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下。
12. import java.io.ByteArrayInputStream;
13. import java.io.ByteArrayOutputStream;
14. import java.io.ObjectInputStream;
15. import java.io.ObjectOutputStream;
16. import java.io.Serializable;
17. public class MyUtil {
18. private MyUtil() {
19. throw new AssertionError();
20. }
21. @SuppressWarnings("unchecked")
22. public static <T extends Serializable> T clone(T obj) throws Exception {
23. ByteArrayOutputStream bout = new ByteArrayOutputStream();
24. ObjectOutputStream oos = new ObjectOutputStream(bout);
25. oos.writeObject(obj);
26. ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
27. ObjectInputStream ois = new ObjectInputStream(bin);
28. return (T) ois.readObject();
29. // 说明：调用 ByteArrayInputStream 或 ByteArrayOutputStream 对象的 close 方法没有任何意义
30. // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
31. }
32. }
测试代码：
1. import java.io.Serializable;
2. /**
3. * 人类
4. */
5. class Person implements Serializable {
6. private static final long serialVersionUID = -9102017020286042305L;
7. private String name; // 姓名
8. private int age; // 年龄
9. private Car car; // 座驾
10. public Person(String name, int age, Car car) {
11. this.name = name;
12. this.age = age;
13. this.car = car;
14. }
15. public String getName() {
16. return name;
17. }
18. public void setName(String name) {
19. this.name = name;
20. }
21. public int getAge() {
22. return age;
23. }
24. public void setAge(int age) {
25. this.age = age;
26. }
27. public Car getCar() {
28. return car;
29. }
30. public void setCar(Car car) {
31. this.car = car;
32. }
33. @Override
34. public String toString() {
35. return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
36. }
37. }
1. /**
2. * 小汽车类
3. */
4. class Car implements Serializable {
5. private static final long serialVersionUID = -5713945027627603702L;
6. private String brand; // 品牌
7. private int maxSpeed; // 最高时速
8. public Car(String brand, int maxSpeed) {
9. this.brand = brand;
10. this.maxSpeed = maxSpeed;
11. }
12. public String getBrand() {
13. return brand;
14. }
15. public void setBrand(String brand) {
16. this.brand = brand;
17. }
18. public int getMaxSpeed() {
19. return maxSpeed;
20. }
21. public void setMaxSpeed(int maxSpeed) {
22. this.maxSpeed = maxSpeed;
23. }
24. @Override
25. public String toString() {
26. return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
27. }
28. }
1. class CloneTest {
2. public static void main(String[] args) {
3. try {
4. Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
5. Person p2 = MyUtil.clone(p1); // 深度克隆
6. p2.getCar().setBrand("BYD");
7. // 修改克隆的 Person 对象 p2 关联的汽车对象的品牌属性
8. // 原来的 Person 对象 p1 关联的汽车不会受到任何影响
9. // 因为在克隆 Person 对象时其关联的汽车对象也被克隆了
10. System.out.println(p1);
11. } catch (Exception e) {
12. e.printStackTrace();
13. }
14. }
15. }
注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对
象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object 类的 clone
方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。
6. 什么是java序列化，如何实现java序列化？
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读
写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现 Serializable 接口，该接口没有需要实现的方法，
implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造
一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就
可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
