Java 基础接口(Serializable、Cloneable、RandomAccess)

最新推荐文章于 2022-04-01 19:04:21 发布

weixin_34315665

最新推荐文章于 2022-04-01 19:04:21 发布

阅读量156

点赞数

文章标签： java python

原文链接：https://my.oschina.net/zfscofield/blog/1593805

版权

2019独角兽企业重金招聘Python工程师标准>>>

一、 java.io.Serializable 接口

public interface Serializable {
}

实现 java.io.Serializable 接口的类是可序列化的。

序列化类的所有子类本身都是可序列化的。

Java序列化的目的主要有： 1.网络传输 2.对象持久化；

基于Java提供的ObjectInputStream/ObjectOutputStream 可以直接将Java对象作为可存储的字节数组写入文件，也可以传输到网络上。

基于JDK默认的序列化机制可以避免直接操作底层的字节数组，从而提升开发效率；

当进行远程跨进程服务调用时，需要把被传输的Java对象编码为字节数组或者ByteBuffer对象，而当远程服务读取到ByteBuffer对象或者字节数组时，需要将其解码为发送时的Java对象，这被称为Java编解码技术；

   # Java 序列化的缺点
   1. 无法跨语言；    RPC框架往往需要支持跨语言调用；
   2. 序列化后的码流太大；
   3. 序列化性能太低

   # 编解码框架的优劣:
   1. 是否支持跨语言，支持的语言种类是否丰富
   2. 编码后的码流大小
   3. 编解码的性能
   4. 类库是否小巧，API使用是否方便
   5. 使用者需要手工开发的工作量和难度

XML 解析的时间开销和 XML 为了可读性而牺牲的空间开销都非常大,因此不适合做高性能的通信协议；

   # Google 的 ProtoBuf 使用二进制编码
   # FaceBoook 的 Thrift
   # JBoss Marshalling

二、java.lang.Cloneable 接口

public interface Cloneable {
}

Cloneable是一个标记接口，没有定义任何方法。原因是：在Java中，所有类的终极父类 java.lang.Object 已经将clone()方法定义为所有类都应该具有的基本功能，只是将该方法声明为了protected类型。该方法定义了逐字段拷贝实例的操作。它是一个native本地方法，因此没有实现体，而且在拷贝字段时，除了Object类的字段外，其子类的新字段也将被拷贝到新的实例中。

既然Object类中已经有了 clone() 方法，为什么还是需要让想具备实力拷贝功能的类实现Cloneable接口呢？其实，Cloneable接口在这里起到了一种标识的作用，表明实现它的类具备了实例拷贝功能，在Cloneable接口的官方javadoc文档中有这样一段话：

"Invoking Object's clone method on an instance that does not implement the Cloneable interface results in the exception CloneNotSupportedException being thrown. JDK1.8"

也就是说，如果一个类不实现该接口就直接调用clone()方法的话，即便已将clone()方法重写为public，那还是会抛出“CloneNotSupportedException”异常。因此，要想使一个类具备拷贝实例的功能，那么除了要重写Object类的clone()方法，把clone()方法修改为public外，还必须要实现Cloneable接口；

1. 浅拷贝

在java中，对象创建后需要有一个引用变量来指向该对象实际的地址空间，也就是说引用变量与对象实体是两个不同的数据体。在Object类的clone()方法中，对对象字段进行复制时，如果字段是基本数据类型（如int、double等），则会复制字段的值到一个新的变量中，而字段是引用类型，则仅会将引用值复制给新对象中的相应字段中，也就是说，两个字段指向了同一个对象实例。

package com.fast.java.a00;

import org.junit.Test;

public class Clone_Test {

    /**
     * 在java中，对象创建后需要有一个引用变量来指向该对象实际的地址空间，也就是说引用变量与对象实体
     * 是两个不同的数据体。在Object类的clone()方法中，对对象字段进行复制时，如果字段是基本数据类型
     * （如int、double等），则会复制字段的值到一个新的变量中，而字段是引用类型，则仅会将引用值复制
     * 给新对象中的相应字段中，也就是说，两个字段指向了同一个对象实例。
     */
    @Test
    public void test_ShallowClone() throws CloneNotSupportedException {

        UserInfo dataObj = new UserInfo("original data");
        StringBuffer strBuf = new StringBuffer("origin data");

        ShallowCloneClass objOrigin = new ShallowCloneClass(dataObj, 1.0, "original", strBuf);
        ShallowCloneClass objCopy = null;
        Object objTemp = objOrigin.clone();
        if (objTemp instanceof ShallowCloneClass) {
            objCopy = (ShallowCloneClass)objTemp;
        }

        /**
         * false说明copy和org是两个不同的对象实例
         * （对于引用类型的比变量，“==”判断的是对象地址是否相同，也就是是不是指向了同一个对象）
         */
        System.out.println("objCopy == objOrigin? " + (objCopy == objOrigin));
        System.out.println();

        System.out.println("data of objOrigin:");
        objOrigin.show();
        System.out.println();
        System.out.println("data of objCopy:");
        objCopy.show();

        /**
         * 但是他们字段的值却是相同的。objCopy和objOrigin各字段的“==”判断全为true也说明本地Object本地
         * clone()对实例引用型字段进行的是浅拷贝。
         */
        System.out.println();
        System.out.println("objOrigin.dataObj == objCopy.dataObj? " + (objOrigin.dataObj == objCopy.dataObj));
        System.out.println("objOrigin.dataDbl == objCopy.dataDbl? " + (objOrigin.dataDbl == objCopy.dataDbl));
        System.out.println("objOrigin.dataStr == objCopy.dataStr? " + (objOrigin.dataStr == objCopy.dataStr));
        System.out.println("objOrigin.dataStrBuf == objCopy.dataStrBuf? " + (objOrigin.dataStrBuf == objCopy.dataStrBuf));


        // 修改copy中各字段指向对象的属性
        objCopy.dataObj.userData = "Copy data";
        objCopy.dataDbl = 2.0;
        objCopy.dataStr = "Copy";
        objCopy.dataStrBuf.replace(0, objCopy.dataStrBuf.length(), "Copy data");

        /**
         * 由于CloneableClass的dataObj和dataStrBuf字段均为引用型变量，所以通过objOrigin浅拷贝出来的
         * objCopy实例中的dataObj和dataStrBuf字段与 objOrigin 中的相应字段实际上指向的是同一个对象，
         * 因此，objCopy 对成员对象的修改也就导致了objOrigin 中相应成员对象的随之改变。
         * 需要说明的是，dataStr 虽然也是引用型变量，但由于字符串是常量，所以语句
         * objCopy.dataStr = “Copy”并没有对原字符串进行修改，
         * 而是将objCopy的 dataStr字段指向了一个新的字符串“Copy”。
         */
        System.out.println();
        System.out.println("After modify, data of original:");
        objOrigin.show();
        System.out.println();
        System.out.println("After modify, data of copy:");
        objCopy.show();
    }
}

class ShallowCloneClass implements Cloneable {

    public UserInfo     dataObj = null;
    public double       dataDbl = 0;
    public String       dataStr = null;
    public StringBuffer dataStrBuf = null;

    public ShallowCloneClass(UserInfo dataObj, double dataDbl, String dataStr, StringBuffer dataStrBuf) {
        this.dataObj = dataObj;
        this.dataDbl = dataDbl;
        this.dataStr = dataStr;
        this.dataStrBuf = dataStrBuf;
    }

    public void show() {
        System.out.println("dataObj = " + dataObj.userData);
        System.out.println("dataDbl = " + dataDbl);
        System.out.println("dataStr = " + dataStr);
        System.out.println("dataStrBuf = " + dataStrBuf);
    }

    /**
     * 重写clone()方法为public类型，并调用Object的本地clone()方法，实现浅拷贝功能
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class UserInfo {

    public String userData = null;

    public UserInfo(String userData) {
        this.userData = userData;
    }
}


输出结果：
objCopy == objOrigin? false

data of objOrigin:
dataObj = original data
dataDbl = 1.0
dataStr = original
dataStrBuf = origin data

data of objCopy:
dataObj = original data
dataDbl = 1.0
dataStr = original
dataStrBuf = origin data

objOrigin.dataObj == objCopy.dataObj? true
objOrigin.dataDbl == objCopy.dataDbl? true
objOrigin.dataStr == objCopy.dataStr? true
objOrigin.dataStrBuf == objCopy.dataStrBuf? true

After modify, data of original:
dataObj = Copy data
dataDbl = 1.0
dataStr = original
dataStrBuf = Copy data

After modify, data of copy:
dataObj = Copy data
dataDbl = 2.0
dataStr = Copy
dataStrBuf = Copy data

2. 深拷贝

从上文讲的浅拷贝概念与性质中不难退出深拷贝的含义，那就是

对于引用型变量，深拷贝会开辟一块新的内存空间，将被复制引用所指向的对象实例的各个属性复制到新的内存空间中，然后将新的引用指向块内存（也就是一个新的实例）。

要想实现深拷贝的功能，我们在重写clone()方法的时候，就不能再简单地调用Object的本地clone()方法，而是要对上文中的CloneableClass做如下修改：

class DeepCloneClass implements Cloneable {

    public UserInfo       dataObj = null;
    public double       dataDbl = 0;
    public String       dataStr = null;
    public StringBuffer dataStrBuf = null;

    public DeepCloneClass(UserInfo dataObj, double dataDbl, String dataStr, StringBuffer dataStrBuf) {
        this.dataObj = dataObj;
        this.dataDbl = dataDbl;
        this.dataStr = dataStr;
        this.dataStrBuf = dataStrBuf;
    }

    public void show() {
        System.out.println("dataObj = " + dataObj.userData);
        System.out.println("dataDbl = " + dataDbl);
        System.out.println("dataStr = " + dataStr);
        System.out.println("dataStrBuf = " + dataStrBuf);
    }

    /**
     * 重写clone()方法为public类型，对每一个字段都创建一个新的对象，并将原字段指向对象中的属性
     * 复制到新的对象中，从而实现深拷贝功能。
     */
    @Override
    public Object clone() throws CloneNotSupportedException {
        UserInfo     dataObj    = new UserInfo(this.dataObj.userData);
        double       dataDbl    = this.dataDbl;
        String       dataStr    = new String(this.dataStr);
        StringBuffer dataStrBuf = new StringBuffer(this.dataStrBuf.toString());

        DeepCloneClass deepCopy = new DeepCloneClass(dataObj, dataDbl, dataStr, dataStrBuf);

        return deepCopy;
    }
}

@Test
public void test_DeepClone() throws CloneNotSupportedException {

    UserInfo dataObj = new UserInfo("original");
    StringBuffer strBuf = new StringBuffer("origin");

    DeepCloneClass objOrigin = new DeepCloneClass(dataObj, 1.0, "original", strBuf);
    DeepCloneClass objCopy = null;
    Object objTemp = objOrigin.clone();
    if (objTemp instanceof DeepCloneClass) {
        objCopy = (DeepCloneClass)objTemp;
    }

    /**
     * false说明copy和org是两个不同的对象实例
     * （对于引用类型的比变量，“==”判断的是对象地址是否相同，也就是是不是指向了同一个对象）
     */
    System.out.println("objCopy == objOrigin? " + (objCopy == objOrigin));
    System.out.println();

    System.out.println("objOrigin.dataObj == objCopy.dataObj? " + (objOrigin.dataObj == objCopy.dataObj));
    System.out.println("objOrigin.dataDbl == objCopy.dataDbl? " + (objOrigin.dataDbl == objCopy.dataDbl));
    System.out.println("objOrigin.dataStr == objCopy.dataStr? " + (objOrigin.dataStr == objCopy.dataStr));
    System.out.println("objOrigin.dataStrBuf == objCopy.dataStrBuf? " + (objOrigin.dataStrBuf == objCopy.dataStrBuf));

    System.out.println();


    // 修改copy中各字段指向对象的属性
    objCopy.dataObj.userData = "Copy data";
    objCopy.dataDbl = 2.0;
    objCopy.dataStr = "Copy";
    objCopy.dataStrBuf.replace(0, objCopy.dataStrBuf.length(), "Copy data");

    System.out.println("After modify, data of original:");
    objOrigin.show();
    System.out.println();
    System.out.println("After modify, data of copy:");
    objCopy.show();
}


输出结果：
objCopy == objOrigin? false

objOrigin.dataObj == objCopy.dataObj? false
objOrigin.dataDbl == objCopy.dataDbl? true
objOrigin.dataStr == objCopy.dataStr? false
objOrigin.dataStrBuf == objCopy.dataStrBuf? false

After modify, data of original:
dataObj = original
dataDbl = 1.0
dataStr = original
dataStrBuf = origin

After modify, data of copy:
dataObj = Copy data
dataDbl = 2.0
dataStr = Copy
dataStrBuf = Copy data

三、 java.util.RandomAccess 接口

public interface RandomAccess {
}

实现 RandomAccess接口，用来表明其支持快速（通常是固定时间）随机访问。

JDK中推荐的是对List集合尽量要实现RandomAccess接口；

如果集合类是RandomAccess的实现，则尽量用for(int i = 0; i < size; i++) 来遍历而不要用Iterator迭代器来遍历，在效率上要差一些。反过来，如果List是Sequence List，则最好用迭代器来进行迭代。

JDK中说的很清楚，在对List特别是Huge size的List的遍历算法中，要尽量来判断是属于RandomAccess(如ArrayList)还是Sequence List (如LinkedList），因为适合RandomAccess List的遍历算法，用在Sequence List上就差别很大，常用的作法就是：

if (list instance of RandomAccess) {
    for(int m = 0; m < list.size(); m++){
    }
}else{
    Iterator iter = list.iterator();
    while(iter.hasNext()){
    }
}

package com.fast.java.a00;

import java.util.*;

public class RandomAccess_Test {

    public static void main(String[] args) {
        ArrayList arraylist = new ArrayList();
        LinkedList linkedlist = new LinkedList();
        initList(arraylist, 1000);
        initList(linkedlist, 1000);

        traverse(arraylist);
        traverse(linkedlist);

        System.out.println("迭代 arraylist: ");
        traverseWithIterator(arraylist);
        traverseWithLoop(arraylist);

        System.out.println("迭代 linkedlist: ");
        traverseWithIterator(linkedlist);
        traverseWithLoop(linkedlist);
    }

    public static void traverse(List list) {
        long starttime = 0;
        long endtime = 0;
        if (list instanceof RandomAccess) {
            System.out.println("该list实现了RandomAccess接口");
            starttime = System.currentTimeMillis();
            for (int count = 0; count <= 1000; count++) {
                for (int i = 0; i < list.size(); i++) {
                    list.get(i);
                }
            }
            endtime = System.currentTimeMillis();
            System.out.println("\tLoop 迭代一共花了" + (endtime - starttime) + "ms时间");
        } else {
            System.out.println("该list未实现RandomAccess接口");
            starttime = System.currentTimeMillis();
            for (int count = 0; count <= 1000; count++) {
                for (Iterator itr = list.iterator(); itr.hasNext();) {
                    itr.next();
                }
            }
            endtime = System.currentTimeMillis();
            System.out.println("\tIterator 迭代一共花了" + (endtime - starttime) + "ms时间");
        }
    }

    public static void initList(List list, int n) {
        for (int i = 0; i < n; i++) {
            list.add(i);
        }
    }

    //使用循环进行对列表的迭代
    public static void traverseWithLoop(List list) {
        long starttime = 0;
        long endtime = 0;
        starttime = System.currentTimeMillis();
        for (int count = 0; count <= 1000; count++) {
            for (int i = 0; i < list.size(); i++) {
                list.get(i);
            }
        }
        endtime = System.currentTimeMillis();
        System.out.println("\t使用loop迭代一共花了" + (endtime - starttime) + "ms时间");
    }

    //使用迭代器对列表进行迭代
    public static void traverseWithIterator(List list) {
        long starttime = 0;
        long endtime = 0;
        starttime = System.currentTimeMillis();
        for (int count = 0; count <= 1000; count++) {
            for (Iterator itr = list.iterator(); itr.hasNext();) {
                itr.next();
            }
        }
        endtime = System.currentTimeMillis();
        System.out.println("\t使用Iterator迭代一共花了" + (endtime - starttime) + "ms时间");
    }
}

输出结果：
该list实现了RandomAccess接口
	Loop 迭代一共花了11ms时间
该list未实现RandomAccess接口
	Iterator 迭代一共花了12ms时间
迭代 arraylist: 
	使用Iterator迭代一共花了16ms时间
	使用loop迭代一共花了10ms时间
迭代 linkedlist: 
	使用Iterator迭代一共花了21ms时间
	使用loop迭代一共花了334ms时间

参考文章： http://blog.csdn.net/u013916933/article/details/51590332

http://blog.csdn.net/keda8997110/article/details/8635005

转载于:https://my.oschina.net/zfscofield/blog/1593805