1.使用RandomAccessFile实现文件合成。
2.使用java中的串行化技术实现对象图(100只猫Cat集合，但是Cat的owner不需要串行化)的深度复制。
3.阐述串行化的过程，应用场景，串行ID的用途。
1.
package com.it18zhang;
/**
* 将分割的文件进行合成
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.RandomAccessFile;
public class App {
public static void main(String[] args) throws Exception {
// 定义分割的小文件类
File[] srcFile = new File[3];
// 合成文件路径
File desFile = new File("d:/file.txt");
RandomAccessFile raf = new RandomAccessFile(desFile, "rw");
for (int i = 0; i < 3; i++) {
srcFile[i] = new File("d:/bb.txt" + "_" + i);
FileInputStream fis = new FileInputStream(srcFile[i]);
byte[] buf = new byte[2];
int len = 0;
while ((len = fis.read(buf)) != -1) {
raf.write(buf, 0, len);
}
fis.close();
}
raf.close();
System.out.println("over");
}
}
package com.it18zhang;
/**
* 文件分割器
*/
import java.io.File;
import java.io.FileOutputStream;
import java.io.RandomAccessFile;
public class FileSplitter {
public static void main(String[] args) throws Exception {
// 源文件
File srcFile = new File("D:\\bb.txt");
// 随机访问
RandomAccessFile raf = new RandomAccessFile(srcFile, "r");
// 文件总长度
long totalLength = srcFile.length();
// 文件份数
int number = 3;
// 计算平均每个文件的长度,最后一份
int fileLength = (int) totalLength / number;
// 循环份数，读写文件
for (int i = 0; i < number; i++) {
System.out.println("循环 : " + i);
// 开始指针
int startIndex = i * fileLength;
// 处理结束指针
int endIndex = 0;
if (i == (number - 1)) {// 最后一份
endIndex = (int) totalLength - 1;
} else {
endIndex = ((i + 1) * fileLength) - 1;
}
// 创建文件输出流
FileOutputStream fos = new FileOutputStream(srcFile.getAbsolutePath() + "_" + i);
raf.seek(startIndex);
// 定义缓冲区
byte[] buf = new byte[2];
while (true) {
// 得到当前文件指针
int currPointer = (int) raf.getFilePointer();
int remain = endIndex - currPointer + 1;
if (remain >= buf.length) {
raf.read(buf);
fos.write(buf);
} else {
raf.read(buf, 0, remain);
fos.write(buf, 0, remain);
}
if (raf.getFilePointer() > endIndex) {
break;
}
}
fos.close();
System.out.println("结束");
}
raf.close();
}
}
2.
package com.it18zhang.deepcopy;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
public class AppCatList {
public static void main(String[] args) throws Exception {
List<Cat> list = new ArrayList<Cat>();
for(int i = 0; i<100; i++){
list.add(new Cat("tom"+i,i+2,i));
}
//写入（串行化）
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/cats.dat"));
oos.writeObject(list);
oos.close();
//读取（反串行化）
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/cats.dat"));
list = (List<Cat>)ois.readObject();
ois.close();
for(Cat c : list){
System.out.println(c.getName()+"-"+c.getAge()+"-"+c.getXx());
}
}
}
package com.it18zhang.deepcopy;
import java.io.Serializable;
public class Cat implements Serializable{
private static final long serialVersionUID = 2781643003919236664L;
private String name;
private int age;
private String color;
private int xx;
public Cat(String name, int age, int xx) {
super();
this.name = name;
this.age = age;
this.xx = xx;
}
//临时的
private transient Person owner;
private Dog neibor;
public Dog getNeibor() {
return neibor;
}
public void setNeibor(Dog neibor) {
this.neibor = neibor;
}
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 String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getXx() {
return xx;
}
public void setXx(int xx) {
this.xx = xx;
}
}
package com.it18zhang.deepcopy;
import java.io.Serializable;
public class Person implements Serializable{
private static final long serialVersionUID = 1513592729849839686L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.it18zhang.deepcopy;
import java.io.Serializable;
public class Dog implements Serializable{
private static final long serialVersionUID = -6027249953977477940L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
3.阐述串行化的过程，应用场景，串行ID的用途。
串行化(Serialization)是计算机科学中的一个概念，它是指将对象存储到介质（如文件、内存缓冲区等）中或是以二进制方式通过网络传输。之后可以通过反串行化从这些连续的字节（byte）数据重新构建一个与原始对象状态相同的对象，因此在特定情况下也可以说是得到一个副本，但并不是所有情况都这样。
1、该对象的类必须实现Serializable接口。
2、该对象的串行化成员必须是非静态成员变量，即不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符，都不能保存。
3、要串行化一个对象，必须与一定的对象输入/输出流联系起来，通过对象输出流将对象状态保存下来，再通过对象输入流将对象状态恢复。
对象序列化功能非常简单、强大，在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。