黑马程序员：IO 学习<二>

------- android培训、java培训、期待与您交流！
----------

(1)--------------------------------对象流,序列化流(理解)

ObjectOutputStream:

void writeObject(Object obj)

ObjectInputStream:

Object readObject()

注意：

A:如果一个类的对象要想被对象流操作，就必须实现序列化接口。

B:这个接口只是起到标识的作用，没有方法需要实现。

C:如果类的简单改动不像影响程序的运行，我们就自己给定序列化id号。

D:序列化：把对象按照流一样的方式在网络中传输和写入文本文件。

反序列化：把文本文件的数据或者网络中传递的流对象数据解析成一个对象。

前面呢，我们已经可以往文件里面写入文本，简单数据。

* 现在呢，我要把一个对象写入到文本文件。该怎么做呢？

* 我们应该定义一个自定类。

* 通过查看API，我们看到了对象的读写：

* ObjectOutputStream：

* void writeObject(Object obj)

* ObjectInputStream：

* Object readObject()

*

* 对象流，序列化流。

*/

public class ObjectStreamDemo {

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

// write();

read();

}

private static void read() throws Exception {

// 反序列化

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(

"oos.txt"));

// 读取数据

Object obj = ois.readObject();

// 释放资源

ois.close();

Person p2 = (Person) obj;

System.out.println(p2.getName() + "***" + p2.getAge());

}

private static void write() throws Exception {

// 我要把Person写到文件

// 创建对象输出流对象

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(

"oos.txt"));

// 写数据

Person p = new Person("林青霞", 25);

oos.writeObject(p);

// 释放资源

oos.close();

}

}

NotSerializableException:

当对象要被序列化流对象操作的时候，必须实现一个接口。

* 通过查看Serializable我们知道类可以通过实现 java.io.Serializable 接口以启用其序列化功能。

* Exception in thread "main" java.io.InvalidClassException:

* cn.itcast_01.Person; local class incompatible: stream classdesc serialVersionUID = 2586984019240964030,

* local class serialVersionUID = -241056507998041204

*

* Serializable是对类打了标记，这个时候，

在生成的class文件中会有一个标记号自动生成。serialVersionUID = 2586984019240964030

* 那么，这样的话，我们把这个对象写入到文件中的时候，

也会把这个标记号写到文件中。serialVersionUID = 2586984019240964030

* 但是，我们刚才的动作，是把写给关闭了，

那么，这个时候，文件中的标记号应该还是：serialVersionUID = 2586984019240964030

* 这个时候，我们又重写在Person类里面修改了一个成员变量的修饰符，一旦修改，这个标记号就会改动。也就是现在的：serialVersionUID = -241056507998041204

* 我们再次读取数据的时候，class中的标记号和文件中的标记号不一致了，就导致了现在的问题。

* class文件和对象写入的文件应该保证一致。

* 我们现在应该去想一个办法，在类中把标记号给固定死，那么，生成的class中的标记号也就是固定的了。

* 问题来了，这个标记号该怎么定义才能让jvm识别。

* 这个就是用来被jvm识别的：private static final long serialVersionUID = -241056507998041204L;

*

*/

public class Person implements Serializable {

*

* 按照序列化的方式写多个对象到文件。

*

* Exception in thread "main" java.io.EOFException:当输入过程中意外到达文件或流的末尾时，抛出此异常。

* 流以-1作为结束条件，而你现在要得到的是一个对象，所以不成功。

*

* 存储多个对象的时候，建议把多个对象添加到一个集合中，把结合对象作为一个对象写入。

* 读取的时候，就读取一次即可。

*

* 总结代码。分类整理。

*/

public class ObjectStreamTest {

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

write();

read();

}

private static void read() throws Exception {

// 反序列化

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(

"oos.txt"));

// 读取数据

// Object obj = ois.readObject();

// Object obj2 = ois.readObject();

// Object obj3 = ois.readObject();

// try {

// Object obj = null;

// while ((obj = ois.readObject()) != null) {

// Person p = (Person) obj;

// System.out.println(p.getName() + "***" + p.getAge());

// }

// } catch (EOFException e) {

// // 但是这样解决不好，这还不如不解决

// // 处理的时候，一定要给出提示，不要认为的把异常给隐藏掉

// }

Object obj = ois.readObject();

ArrayList<Person> array = (ArrayList<Person>) obj;

for (Person p : array) {

System.out.println(p.getName() + "***" + p.getAge());

}

// 释放资源

ois.close();

// Person p = (Person) obj;

// System.out.println(p.getName() + "***" + p.getAge());

// Person p2 = (Person) obj2;

// System.out.println(p2.getName() + "***" + p2.getAge());

// Person p3 = (Person) obj3;

// System.out.println(p3.getName() + "***" + p3.getAge());

}

private static void write() throws Exception {

// 我要把Person写到文件

// 创建对象输出流对象

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(

"oos.txt"));

// 写数据

Person p = new Person("林青霞", 25);

// oos.writeObject(p);

Person p2 = new Person("林志玲", 22);

// oos.writeObject(p2);

Person p3 = new Person("刘德华", 40);

// oos.writeObject(p3);

ArrayList<Person> array = new ArrayList<Person>();

array.add(p);

array.add(p2);

array.add(p3);

oos.writeObject(array);

// 释放资源

oos.close();

}

}

打印流：

* PrintWriter://字符打印流

* PrintStream://字节打印流

*

* 为什么要学习Print呢？

* 特点：

* 1：可以把任意类型的数据写入文件

* 2：它是可以直接操作设备(文件)的流对象流对象很多，那么，哪些流对象时可以直接操作文件的呢？

* 观察构造方法，如果可以传递File file参数和String fileName参数同时存在，

说明该流对象就是可以操作文件的对象。

* 3：能够自动刷新。前提是：要启动自动刷新，使用println、printf 或 format的时候才可以。

* 不但能够刷新，还能够自动换行。

*/

public class PrintWriterDemo {

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

// write1();

// write2();'

write3();

}

// 使用println方法自动刷新

private static void write3() throws IOException {

// 创建打印流对象,启用自动刷新

PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true);

// 写入数据

pw.println("haha");

pw.println("hehe");

pw.println("xixi");

pw.println("heihei");

pw.println("gaga");

//释放资源

pw.close();

}

// 使用print方法写入不同数据类型的数据

private static void write2() throws IOException {

// 创建对象

PrintWriter pw = new PrintWriter("b.txt");

// 写入数据

pw.print(true);

pw.print(123);

pw.print("hell");

pw.flush();

pw.close();

}

// PrintWriter作为基本的Writer体系的使用

private static void write1() throws IOException {

// 创建打印流对象

PrintWriter pw = new PrintWriter("a.txt");

// 下面这个不可以

// BufferedWriter bw = new BufferedWriter("a.txt");

// 调用pw的write方法

pw.write("hello");

pw.flush();

// 释放资源

pw.close();

}

}

Properties:是Hashtaable的子类，具有Map集合的特点。它还可以和io进行结合使用。它的键和值都是字符串。

Properties作为Map体系使用。

把Properties集合中的数据写入到文本文件中。

思路：

1：得到有数据的集合对象。

2：遍历集合，获取键和值

3：把键和值存入文件

那么， 什么又是我们说的结合呢？

也就是说，我们不需要看到基本的读写操作。

特殊方法：

1：根据键获取值

* String getProperty(String key):根据键获取值

* String getProperty(String key, String defaultValue):当键对应的值存在，就返回值，否则，就返回给定的默认值。

* Object setProperty(String key, String value):当键存在的时候，就是修改动作，当键不存在的时候，就是添加动作。

*

* 2：load:把键值对的文本数据加载到集合中

* load(InputStream is)

* load(Reader r)

2：list 把集合中的数据写入文本文件

list(PrintStream out)

list(PrintWriter out)

3：load:把键值对的文本数据加载到集合中

* load(InputStream is)

* load(Reader r)

4： store:保存数据(重新保存到Properties里面的文件里面)

store(OutputStream os,String str)

store(Writer w,String str)

JDK的bin目录下有一个工具：

1、native2ascii a.txt b.txt

2、native2ascii b.txt -reverse c.txt

例：------

public class PropertiesDemo {

public static void main(String[] args) {

// 创建集合对象

Properties prop = new Properties();

System.out.println("prop:" + prop);

prop.put("hello", "haha");

prop.put("world", "hehe");

System.out.println("prop:" + prop);

// 遍历方式

Set<Object> set = prop.keySet();

Iterator<Object> it = set.iterator();

while (it.hasNext()) {

Object key = it.next();

Object value = prop.get(key);

System.out.println(key + "***" + value);

}

}

}

例：

*

* 请问应用在哪里？

* 玩过游戏吗？加载游戏进度。

*/

public class PropertiesDemo3 {

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

// 创建集合对象

Properties prop = new Properties();

System.out.println("prop:" + prop);

// load(Reader r)

FileReader fr = new FileReader("prop.txt");

prop.load(fr);

fr.close();

System.out.println("prop:" + prop);

}

}

/*

* 游戏进度的保存。

*/

public class PropertiesDemo4 {

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

Properties prop = new Properties();

// 把文本文件中的键值对数据加载到集合中

FileReader fr = new FileReader("prop.txt");

prop.load(fr);

fr.close();

// System.out.println("prop:" + prop);

prop.setProperty("lisi", "50");

// System.out.println("prop:" + prop);

// 保存数据

// store(Writer w,String str);

FileWriter fw = new FileWriter("prop.txt");

prop.store(fw, "name and age"); // 第二个参数其实就是解释说明数据的意义

fw.close();

}

}

JDK的bin目录下有一个工具：

native2ascii a.txt b.txt

native2ascii b.txt -reverse c.txt

查找文件prop.txt中，看有没有键为lisi的值，如果有，则把其值修改为35

*

* 思路：

1：把prop.txt中的键值对数据加载到Properties集合中。load

2：遍历这个集合，获取到每一个键，进行判断。

如果有键为lisi的，则把其值修改为35

3：最后，把改变后的集合数据保存到prop.txt文件中。store

*/

public class PropertiesTest {

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

// 把prop.txt中的键值对数据加载到Properties集合中。

Properties prop = new Properties();

FileReader fr = new FileReader("prop.txt");

prop.load(fr);

fr.close();

// System.out.println("prop:" + prop);

// 遍历这个集合，获取到每一个键，进行判断。

Set<Object> set = prop.keySet();

for (Object key : set) {

if ("lisi".equals(key)) {

prop.setProperty(String.valueOf(key), String.valueOf(35));

break;

}

}

// 最后，把改变后的集合数据保存到prop.txt文件中

FileWriter fw = new FileWriter("prop.txt");

prop.store(fw, "这是数据表示姓名和年龄");

fw.close();

}

}

编码表：就是由数字及其表示的字符组成的一张数据表：

ASCII

ISO-8859-1码表

GBK

GBK2312

BIG5

UTF-8

UTF-16

为了实现国际化，国际化标准组织，就做了统一规定，用统一的编码表。

unicode编码。

字符串编码问题：

*

* 编码：

* 把能够看懂的变成看不懂的。

* String -- getBytes()

* 解码：

* 把看不懂的变成能够看懂的。

* byte[] -- String

*/

----------------------------------------------------------

public class StringEncode {

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

// 创建一个字符串

String str = "你好";

// 编码

// byte[] bys = str.getBytes();

// -60, -29, -70, -61

// byte[] bys = str.getBytes("GBK");

// -28, -67, -96, -27, -91, -67

byte[] bys = str.getBytes("UTF-8");

System.out.println("bys:" + Arrays.toString(bys));

// 解码

// String s = new String(bys);

// 浣犲ソ

String s = new String(bys, "GBK");

// ???

// String s = new String(bys, "UTF-8");

System.out.println("s:" + s);

}

}

------------------------------------------

* 在IO流操作中的编码问题：

* 如果你想在io流操作中指定编码，得使用转换流。

* 只有转换流才可以指定编码。

* 字符流 = 字节流 + 编码表

*/

public class EncodeDemo {

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

// 这里使用了默认编码表GBK

// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

// "osw.txt"));

// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

// "osw.txt"), "GBK");

// FileWriter osw = new FileWriter("osw.txt");

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(

"osw.txt"), "UTF-8");

osw.write("中国");

osw.close();

// InputStreamReader isr = new InputStreamReader(new FileInputStream(

// "osw.txt"), "UTF-8");

InputStreamReader isr = new InputStreamReader(new FileInputStream(

"osw.txt"), "GBK");

char[] chs = new char[1024];

int len = isr.read(chs);

System.out.println(String.copyValueOf(chs, 0, len));

isr.close();

}

}

如果保证数据不出现乱码的现象。就把编码改成相同的样式

如何使用面向对象的思想思考问题

1、分析该系统有哪些类

2、每个类有哪些成员

3、类的相互调用关系

------- android培训、java培训、期待与您交流！
----------