-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------
一、对象序列化
ObjectOutputStram和ObjectInputStream
1、概述：
将堆内存中的对象存入硬盘，保留对象中的数据，称之为对象的持久化（或序列化）
2、特有方法：
write(int val) ---> 写入一个字节（最低八位）
writeInt(int vale) ---> 写入一个32位int值
3、使用步骤：
（1）写入流对象：
1）创建对象写入流，与文件关联，即传入目的
2）通过写入writeObject()方法，将对象作为参数传入，即可写入文件
（2）读取流对象
1）创建对象读取流，与文件关联，即传入源
2）通过writeObject()方法，读取文件中的对象，并返回这个对象
4、说明：serialVersion
a、给类一个可被编译器识别的的序列号，在编译类时，会分配一个long型UID，通过序列号，将类存入硬盘中，并序列化，即持久化。序列号根据成员算出的。静态不能被序列化。如果非静态成员也无需序列化，可以用transien修饰。
代码示例：
b、接口Serializable中没有方法，称之为标记接口
5、代码示例：
import java.io.*;
//创建Person类，实现序列化
class Person implements Serializable {
// 定义自身的序列化方式
public static final long serialVersionUID = 42L;
// 定义私有属性
private String name;
private int age;
transient String id;
String country = "cn";
// 构造Person类
Person(String name, int age, String id, String country) {
this.name = name;
this.age = age;
this.id = id;
this.country = country;
}
// 覆写toString方法
public String toString() {
return name + ":" + age + ":" + id + ":" + country;
}
}
// 对象序列化测试
class ObjectStreamDemo {
public static void main(String[] args) {
// 对象写入流
writeObj();
// 对象读取流
readObj();
}
// 定义对象读取流
public static void readObj() {
ObjectInputStream ois = null;
try {
// 创建对象读取流
ois = new ObjectInputStream(new FileInputStream("obj.txt"));
// 通过读取文件数据，返回对象
Person p = (Person) ois.readObject();
System.out.println(p);
} catch (Exception e) {
throw new RuntimeException("写入文件失败");
}
// 最终关闭流对象
finally {
try {
if (ois != null)
ois.close();
} catch (IOException e) {
throw new RuntimeException("写入流关闭失败");
}
}
}
// 定义对象写入流
public static void writeObj() {
ObjectOutputStream oos = null;
try {
// 创建对象写入流
oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
// 写入对象数据
oos.writeObject(new Person("lisi", 25, "01", "cn"));
} catch (Exception e) {
throw new RuntimeException("写入文件失败");
}
// 关闭流资源
finally {
try {
if (oos != null)
oos.close();
} catch (IOException e) {
throw new RuntimeException("写入流关闭失败");
}
}
}
}
二、RandomAccessFile 类(重要！！！)
1、概述：
（1）自身具备读写方法(很牛逼！又可以读又可以写)
（2）通过skipByte(int x)和seek(int x)来达到随机访问文件
（3）该类不是IO体系子类，而是直接继承Object，但它是IO包中的成员，因为它具备读写方法
（4）该类内部封装了数组，而且通过指针对数组的元素进行操作，可以通过getFilePoint获取指针位置，同时可以通过seek改变指针位置
（5）该类可以完成读写的原理是：内部封装了字节输入输出流
（6）构造函数：RandomAccessFile(File file,String mode)，RandomAccessFile(String name, String mode)，可已从它的构造函数中看出，该类只能操作文件（也有字符串），而且操作文件还有模式。
模式传入值：”r“：以只读方式打开；”rw“：打开以便读写
如果模式为只读，则不会创建文件，会去读一个已存在的文件，若文件不存在，则会出现异常，如果模式为rw，且该对象的构造函数要操作的文件不存在，会自动创建，如果存在，则不会覆盖，也可通过seek方法修改。
（7）可用于多线程分段写入，即：下载原理
2、特有方法：
（1）seek(int n)：设置指针，可以将指针设置到前面或后面
（2）skipBytes(int n)：跳过指定字节数，不可往前跳
3、使用步骤：
（1）创建RandomAccessFile对象
（2）将数据写入到指定文件中
（3）读取数据，读入到指定文件中
注意：要读取后面的数据，需要调用数组指针，通过改变角标位置，取出相应的数据，即：
a.调整对象的指针：seek()
b.跳过指定字节数
4、代码示例：
import java.io.*;
//注:这几个函数内部都需要try，为测试，在函数上抛异常
class RanAccFileDemo {
public static void main(String[] args) throws IOException {
// readRaf();
readRaf2();
// writeRaf();
}
// 写入数据
public static void writeRaf() throws IOException {
// 创建对象，写入数据
RandomAccessFile raf = new RandomAccessFile("ran.txt", "rw");
raf.write("王五".getBytes());
raf.writeInt(99);
raf.write("李四".getBytes());
raf.writeInt(97);
raf.close();
}
// 读取数据
public static void readRaf() throws IOException {
// 创建对象，读取数据
RandomAccessFile raf = new RandomAccessFile("ran.txt", "r");
byte[] b = new byte[4];
raf.read(b);
String name = new String(b);
int age = raf.readInt();
System.out.println("name=" + name);
System.out.println("age=" + age);
raf.close();
}
// 读取数据
public static void readRaf2() throws IOException {
// 创建对象，读取数据
RandomAccessFile raf = new RandomAccessFile("ran.txt", "r");
// 调整对象中的指针
// raf.seek(8);
// 跳过指定字节数
raf.skipBytes(8);
byte[] b = new byte[4];
raf.read(b);
String name = new String(b);
int age = raf.readInt();
System.out.println("name=" + name);
System.out.println("age=" + age);
raf.close();
}
}
三、字符编码
1、概述：
（1）字符流的出现为了方便操作字符，更重要的是加入了编码的转换，即转换流。
（2）通过子类进行转换
（3）在两个对象进行构造时，可加入编码表
（4）可传入编码表的有：
1）转换流：InuputStreamReader和OutputStreamWriter
2）打印流：PrintStream和PrintWriter，只有输出流
（5）常见的编码表：
1）ASCII：美国标准信息交换码表。用一个字节的7位表示
2）IOS8859-1：拉丁码表；欧洲码表。用一个字节的8位表示
3）GB2312：中国的中文编码表
4）GBK：中国的中文编码表升级，融合了更多的中文文字字符。打头的是两个高位为1的两个字节编码。为负数
5）Unicode：国际标准码，融合了多种文字
6）UTF-8：最多用三个字节表示一个字符的编码表，包括：一位、两位、三位表示的字符
UTF-8有自己的字节码：
一个字节：0开头
两个字节：字节一 ---> 110 位数：10 ~ 6
字节二 ---> 10 位数：5 ~ 0
三个字节：字节一 ---> 110 位数：15 ~ 12
字节二 ---> 10 位数：11 ~ 6
字节三 ---> 10 位数：5 ~ 0
2、编码和解码
（1）编码和解码：
1）编码：字符串变成字节数组
2）解码：字节数组变成字符串
（2）转换：
1）默认字符集：
String ---> byte[] ：srt.getBytes()
byte[] ---> String ：ne编码w String(byte[])
2）指定字符集：
String ---> byte[] ：srt.getBytes(charsetName)
byte[] ---> String ：new String(byte[],charsetName)
（3）对于编码和解码的字符集转换
1）如果编码失败，解码就没意义了。
2）如果编码成功，解码出来的是乱码，，则需对乱码通过再次编码（用解错码的编码表），然后再通过正确的编码表解码。针对于IOS8859-1是通用的。
3）如果用的是GBK编码，UTF-8解码，那么再通过2的方式，就不能成功了，因为UTF-8也支持中文，在UTF-8解的时候，会将对应的字节数改变，所以不会成功。
（4）特别注意：
对于中文的”联通“，这两个字比较特别，它的二进制位正好是和在UTF-8中两个字节打头的相同，可以找到对应的符号，但不再是”联通“了。
3、代码示例：
import java.util.*;
class EncodeDemo {
public static void main(String[] args) throws Exception {
CodeDemo();
// 编译成功，解码失败后的解决方式
CodeBack();
}
public static void CodeDemo() throws Exception {
String s = "你好";
byte[] b1 = s.getBytes();
String s1 = new String(b1);
System.out.println(Arrays.toString(b1));
byte[] b2 = s.getBytes("GBK");// 默认编码
String s2 = new String(b2);
System.out.println("s1=" + s1 + ",s2=" + s2);
System.out.println(Arrays.toString(b2));
byte[] b3 = s.getBytes("UTF-8");// 国际编码
String s3 = new String(b3);
System.out.println("s3=" + s3);
System.out.println(Arrays.toString(b3));
byte[] b4 = s.getBytes("ISO8859-1");// 欧洲编码
String s4 = new String(b4);
System.out.println("s4=" + s4);
System.out.println(Arrays.toString(b4));
}
// 编码与解码
public static void CodeBack() throws Exception {
String s = "你好";
System.out.println("原数据：" + s);
byte[] b1 = s.getBytes("GBK");// 默认编码
System.out.println(Arrays.toString(b1));
String s1 = new String(b1, "ISO8859-1");
System.out.println("s1=" + s1);
System.out.println("----对s1进行ISO8859-1编码-----");
// 对s1进行ISO8859-1编码
byte[] b2 = s1.getBytes("ISO8859-1");// 欧洲编码
System.out.println(Arrays.toString(b2));
String s2 = new String(b2, "GBK");
System.out.println("s2=" + s2);
}
}
/*output:
[-60, -29, -70, -61]
s1=你好,s2=你好
[-60, -29, -70, -61]
s3=浣犲ソ
[-28, -67, -96, -27, -91, -67]
s4=??
[63, 63]
原数据：你好
[-60, -29, -70, -61]
s1=????
----对s1进行ISO8859-1编码-----
[-60, -29, -70, -61]
s2=你好
*/
四、综合练习
五个学生，每个学生有3门课程的成绩，从键盘输入以上数据（姓名，三门课成绩），
输入格式：如：zahngsan，30,40,60计算出总成绩，并把学生的信息和计算出的总分数高低按顺序存放在磁盘文件stud.txt中
步骤：
1、描述学生对象
2、定义一个可操作学生对象的工具类
思路：
1、通过获取键盘录入一行的数据，并将该行数据的信息取出，封装成学生对象
2、因为学生对象很多，则需要存储，使用集合，因为要对学生总分排序
所以可以使用TreeSet
3、将集合中的信息写入到一个文件中
import java.io.*;
import java.util.*;
//定义学生类
class Student implements Comparable<Student> {
// 定义私有属性
private String name;
private int ma, cn, en;
private int sum;
// 构造Student函数，初始化
Student(String name, int ma, int cn, int en) {
this.name = name;
this.ma = ma;
this.cn = cn;
this.en = en;
sum = ma + cn + en;
}
// 覆写compareTo方法，按学生总成绩排序
public int compareTo(Student s) {
int num = new Integer(this.sum).compareTo(new Integer(s.sum));
if (num == 0)
return this.name.compareTo(s.name);
return num;
}
// 获取学生信息
public String getName() {
return name;
}
public int getSum() {
return sum;
}
// 覆写hasdCode()和equals()方法，排除相同的两个学生
public int hashCode() {
return name.hashCode() + sum * 39;
}
public boolean equals(Object obj) {
if (obj instanceof Student)
throw new ClassCastException("类型不匹配");
Student s = (Student) obj;
return this.name.equals(s.name) && this.sum == s.sum;
}
// 定义学生信息显示格式
public String toString() {
return "student[" + name + ", " + ma + ", " + cn + ", " + en + "]";
}
}
// 工具类，将键盘录入的输入存入集合，并将集合的元素写入文件中
class StudentInfoTool {
// 无比较器的学生集合
public static Set<Student> getStudents() {
return getStudents(null);
}
// 具备比较器的学生集合
@SuppressWarnings("finally")
public static Set<Student> getStudents(Comparator<Student> cmp) {
BufferedReader bufr = null;
Set<Student> stus = null;
try {
// 创建读取流对象缓冲区，键盘录入
bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
// 选择集合是否有比较器
if (cmp == null)
stus = new TreeSet<Student>();
else
stus = new TreeSet<Student>(cmp);
// 循环读取键盘录入的数据
while ((line = bufr.readLine()) != null) {
if ("over".equals(line))
break;
// 对读取的数据进行分割并存入集合
String[] info = line.split(",");
Student stu = new Student(info[0], Integer.parseInt(info[1]),
Integer.parseInt(info[2]), Integer.parseInt(info[3]));
stus.add(stu);
}
} catch (IOException e) {
throw new RuntimeException("学生信息读取失败");
}
// 关闭流资源
finally {
try {
if (bufr != null)
bufr.close();
} catch (IOException e) {
throw new RuntimeException("读取流关闭失败");
}
return stus;
}
}
// 将数据写入指定文件
public static void write2File(Set<Student> stus, String fileName) {
BufferedWriter bufw = null;
try {
// 创建写入流对象
bufw = new BufferedWriter(new FileWriter(fileName));
// 循环写入数据
for (Student stu : stus) {
bufw.write(stu.toString() + "\t");
bufw.write(stu.getSum() + "");
bufw.newLine();
bufw.flush();
}
} catch (IOException e) {
throw new RuntimeException("读取流关闭失败");
}
// 关闭流资源
finally {
try {
if (bufw != null)
bufw.close();
} catch (IOException e) {
throw new RuntimeException("写入流关闭失败");
}
}
}
}
class Demo {
public static void main(String[] args) {
// 反转比较器，将成绩从大到小排
Comparator<Student> cmp = Collections.reverseOrder();
// 将录入的学生信息存入集合
Set<Student> stus = StudentInfoTool.getStudents(cmp);
// 将信息写入指定文件中
StudentInfoTool.write2File(stus, "sudentinfo.txt");
}
}