IT十八掌作业_java基础第十五天_IO串行化/深度复制

Posted 2020-07-28

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都有应用。对象序列化问题在网络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。

本文出自 “菜鸟成就数据之路” 博客，转载请与作者联系！