ArrayList中标记性接口介绍----Serializable、Cloneable、RandomAccess

最新推荐文章于 2022-10-24 13:28:59 发布
最新推荐文章于 2022-10-24 13:28:59 发布
阅读量244 收藏
点赞数 1
文章标签： java 标志性接口 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xueyijin/article/details/114335300
版权

文章目录

0. 前言

  1. 通过这篇文章你可以了解Serializable、Cloneable、RandomAccess这些标记性接口的作用。
  2. 你可以了解到什么是浅拷贝、什么是深拷贝。
  3. 什么是随机访问、什么是顺序访问

1. Serializable序列化接口

  1. 序列化接口没有方法或字段，仅仅用于标识可串行化的语义。

  2. 类的序列化由实现Serializable接口的类启动。不实现此接口的类将不会使用任何状态序列化或者反序列化。

  3. 序列化：将对象的数据写入到文件(写对象)

  4. 反序列化：将文件中对象的数据读取出来(读对象)

  5. 代码例子：

    import java.io.*;

/**
 * @author JIN
 * @description 序列化
 * @createTime 2021-03-03 18:27
 **/
public class Test1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person p = new Person("小明",18);

        // 序列化 写对象
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("src/data1.txt"));
        out.writeObject(p);

        // 反序列化  读对象
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("src/data1.txt"));
        Person object = (Person) in.readObject();
        System.out.println(object);
    }
}
// 一定要实现Serializable接口
class Person implements Serializable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. Cloneable克隆标记性接口: 用于克隆

  1. 一个类实现Cloneable接口来指示Object.clone()方法，该方法对于该类的实例进行字段的复制是合法的

  2. 在不现实Cloneable接口的实例上调用对象的克隆方法会导致异常CloneNotSupportedException被抛出.

  3. 克隆就是依据有的数据，创造一份新的完全一样的数据拷贝。

  4. 克隆的前提条件：

    1. 被克隆对象所在的类必须实现Cloneable接口
    2. 必须重写clone方法

  5. 代码例子：

    public class CloneableTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        Object clone = list.clone();
        System.out.println(clone); // [a, b, c]
        // 说明只是复制了数据内容。
        System.out.println(clone == list); // false
    }
}

3. 传统方法拷贝

  1. 题目：现有一个User对象[name=“小明”，age=18]，需要得到一个与之数据相同的对象User2.

  2. 传统代码：

    /**
 * @author JIN
 * @description
 * @createTime 2021-03-03 18:46
 **/
public class User {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    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 class Test2 {
    public static void main(String[] args) {
        User user1 = new User("小明",18);
		// 直接将user1的值赋给user2，但如果属性很多，十几个的时候，我们就觉得很繁琐
        User user2 = new User();
        user2.setName(user1.getName());
        user2.setAge(user1.getAge());
        System.out.println(user2);
        
       	// 修改user1的属性，查看user2是否会改变---不会改变
        user1.setAge(2000);
        System.out.println(user);// User{name='小明', age=2000}
        System.out.println(cloneUser); // User{name='小明', age=18}
    }
}

4. 浅拷贝与深拷贝

  1. 克隆的前提条件：

    1. 被克隆对象所在的类必须实现Cloneable接口
    2. 必须重写clone方法

  2. 浅拷贝的实现方法：

    // 修改User类
public class User implements Cloneable{
    // 重写方法的时候，把方法的权限修饰符更改为public
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
	// 其他代码不变
}

    public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user1 = new User("小明",18);

        // 代码明显比传统方法简单很多
        User cloneUser = (User) user1.clone();
        System.out.println(cloneUser); //User{name='小明', age=18}
        
        // 修改user1的属性，查看user2是否会改变---不会改变
        user1.setAge(2000);
        System.out.println(user);// User{name='小明', age=2000}
        System.out.println(cloneUser); // User{name='小明', age=18}
    }
}

    但是浅拷贝也有自己的局限性：基本数据类型可以达到完全复制，但是引用数据类型则不可以，对于引用数据类型来说仅仅是拷贝了一份引用。即若对引用数据类型进行修改，拷贝哪一方也会一起修改。

    代码演示：

    public class School {
    private String name;

    public School(String name) {
        this.name = name;
    }
    
    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                '}';
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


public class User implements Cloneable{

    private String name;
    private int age;
    // 添加一个引用数据类型
    private School school;

    public User(String name, int age, School school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }

    public User() {
    }

    public School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        this.school = school;
    }

    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 class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user1 = new User("小明",18,new School("北京"));

        User cloneUser = (User) user1.clone();
        System.out.println(cloneUser);
        System.out.println("---------------");
        // 修改user1的学校，查看cloneUser是否会改变----会一起变
        user1.getSchool().setName("上海");
        System.out.println("user1: " + user1);
        System.out.println("cloneUser: " + cloneUser);
    }
}

    User{name='小明', age=18, school=School{name='北京'}}
---------------
user1: User{name='小明', age=18, school=School{name='上海'}}
cloneUser: User{name='小明', age=18, school=School{name='上海'}}

    从上面结果，我们看到了当user1修改了学校的名字，cloneuser中学校的名字也一起改变了，显然这不是我们想要的结果，我们只是想要数据的内容的复制就好了，不需要有关系、关联。

    原因：在学生对象user被克隆的时候，其属性School(引用类型)仅仅是拷贝了一份引用，因此在School的值发生改变的时候，被克隆对象cloneuser的属性也会改变。

    解决方案：使用深拷贝。

  3. 深拷贝代码：

    针对上面浅拷贝的问题，我们并不能简单的调用父类的clone，需要自己重写clone中代码。

    // 对于school类，修改如下：
public class School implements Cloneable{

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
 
    // 其他不变
}

    // 对于user类，修改如下：
public class User implements Cloneable{
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        // 1. 先克隆出一个user对象
        User cloneUser = (User) super.clone();
        // 2. 再克隆出一个引用类型的对象
        School cloneSchool = (School) this.school.clone();
        // 3. 将引用类型的新对象赋值给克隆出来的cloneUser
        cloneUser.setSchool(cloneSchool);
        // 克隆出来的cloneSchool相当于新的一个对象，与原来的school对象并没用关联。
        // 4. 返回克隆对象
        return cloneUser;
    }
 
    // 其他不变
}

    public class Test2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user1 = new User("小明",18,new School("北京"));

        User cloneUser = (User) user1.clone();
        System.out.println(cloneUser);
        System.out.println("---------------");
        // 修改user1的学校，查看cloneUser是否会改变----不会一起变
        user1.getSchool().setName("上海");
        System.out.println("user1: " + user1);
        System.out.println("cloneUser: " + cloneUser);
    }
}


重新测试结果：
User{name='小明', age=18, school=School{name='北京'}}
------------------------------------------------
user1: User{name='小明', age=18, school=School{name='上海'}}
cloneUser: User{name='小明', age=18, school=School{name='北京'}} // 没改变

5. RandomAccess标记接口：支持快速的随机访问

  1. 作用：是允许通用算法更改其行为，以便在应用于随机访问列表或者顺序访问列表时提供良好的性能。

  2. 此接口由list实现使用，以表明它们支持快速的随机访问。 实现了这个接口的集合是支持快速随机访问策略的。

  3. 通俗来说： 如果是实现了这个接口的 List，那么使用for循环的方式（随机访问)获取数据会优于用**迭代器(顺序访问)**获取数据。

  4. 什么是随机访问：

    for(int i = 0; i < 10; i++)
    list.get(i);

  5. 什么是顺序访问：

    while (iterator.hasNext()){
        Object next = iterator.next();
}

  6. 验证代码：

    public class Test3 {
    public static void main(String[] args) {
        // 实现了RandomAccess接口----for方法更加快
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(i);
        }
        // for方法 随机访问
        t1(list);
        // 迭代器 顺序访问
        t2(list);
    }

    private static void t1(ArrayList<Integer> list) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            Object object = list.get(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("for随机访问消耗的时间: " + (end - start));
    }

    private static void t2(ArrayList<Integer> list) {
        long start = System.currentTimeMillis();
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Object object = iterator.next();
        }
        long end = System.currentTimeMillis();
        System.out.println("iterator顺序访问消耗的时间: " + (end - start));
    }
}

    运行结果：
for随机访问消耗的时间: 6
iterator顺序访问消耗的时间: 7

  7. 我们使用LinkedList来测试一下，LinkedList并没实现RandomAccess接口。

    public class Test3 {
    public static void main(String[] args) {
        // LinkedList 没有实现了RandomAccess接口----iterator方法更加快
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 0; i < 100000; i++) {
            list.add(i);
        }
        // for方法 随机访问
        t1(list);
        // 迭代器 顺序访问
        t2(list);
    }

    private static void t1(LinkedList<Integer> list) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < list.size(); i++) {
            Object object = list.get(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("for随机访问消耗的时间: " + (end - start));
    }

    private static void t2(LinkedList<Integer> list) {
        long start = System.currentTimeMillis();
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Object object = iterator.next();
        }
        long end = System.currentTimeMillis();
        System.out.println("iterator顺序访问消耗的时间: " + (end - start));
    }
}

    运行结果：
for随机访问消耗的时间: 6542
iterator顺序访问消耗的时间: 7

    小结：

    1. 如果实现了RandomAccess接口，则for方法遍历比iterator迭代器方法遍历好，如：Arraylist。
    2. 如果没实现，如上面例子LinkedList，则迭代器方法远优于for方法遍历。
搏·梦
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
jdk源码之ArrayList实现Serializable空架子
m0_58532927的博客
10-23 102
Java序列化是指把Java对象转换为字节序列的过程；Java反序列化是指把字节序列恢复为Java对象的过程。两个流：objectOutputStream、ObjectInputStreamserialVersionUID的作用Serializable与Externalizable的关系transient关键字在实现Serializable里有效果在实现Externalizable接口中无效。
java中的标志性接口
技术分享
04-17 4074
在java 中，RandomAccess和Cloneable 、Serializable一样，都是标志性接口，不需要任何实现，只是又来表明其实现类具体有某种特质的，实现了Cloneable表明可以拷贝，实现Serializable 接口表明被序列化了，实现RandomAccess接口则表明这个类可以随机存取。
Java的四个标记接口：Serializable、Cloneable、RandomAccess和Remote接口
weixin_30907935的博客
04-17 159
一、概述 标记接口是一些没有属性和方法的接口，也是一种设计思想。Java中的一个标记接口表示的的是一种类的特性，实现了该标记接口的类则具有该特性。如实现了Serializable接口的类，表示这个类的对象是可以进行序列化和反序列化的。Java中常见的标记接口还有Cloneable接口、RandomAccess接口和Remote接口。可以用 if（对象名 instance...
java之标记性接口
qq_42730111的博客
10-14 756
标记性接口作用和理解 标识接口是没有任何方法和属性的接口。标识接口不对实现它的类有任何语义上的要求，它仅仅表明实现它的类属于一个特定的类型。 效果 标记接口在Java语言中有一些很著名的应用，在java 中，RandomAccess和Cloneable 、Serializable一样，都是标志性接口，不需要任何实现，只是又来表明其实现类具体有某种特质的。 实现了Cloneable表明可以拷贝 实现Serializable 接口表明被序列化了 实现RandomAccess接口则表明这个类可以随机存取。 功
Java中的标记接口（标签接口）
小鲁蛋的博客
09-14 2317
Java中的标记接口（Marker Interface），又称标签接口（Tag Interface），具体是不包含任何方法的接口。简单一句话描述标记接口就是用来判断某个类是否具有某个能力的首先明确一点，Marker Interface（标记接口）决不是Java这门编程语言特有的，而是。上面这段话是维基百科对标记接口的定义。具体说的就是：标记接口是计算机科学中的一种设计思路。编程语言本身不支持为类维护元数据。而标记接口则弥补了这个功能上的缺失——
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList继承自AbstractList，并实现了List、RandomAccess、Cloneable和Serializable接口。这意味着ArrayList提供了顺序访问和随机访问的高效性，支持克隆和序列化，同时也意味着其内部数据是以数组的形式存储。 *...
JAVA ArrayList详细介绍(示例)
09-04
- **快速随机访问**：由于ArrayList基于数组，可以使用索引快速访问任何位置的元素，实现了RandomAccess接口，提供了高效的随机访问性能。 - **非线程安全**：ArrayList的操作不是线程安全的，如果在多线程环境下...
java关键字ArrayList详解
最新发布
07-04
ArrayList继承自AbstractList，实现了List接口，RandomAccess接口，Cloneable接口和Serializable接口。实现List接口意味着ArrayList必须提供一系列用于添加、删除、修改和查找元素的方法。RandomAccess接口是一个...
Java ArrayList 实现实例讲解
09-01
在Java中，ArrayList类位于`java.util`包下，它实现了`List`接口，同时也实现了`Serializable`、`Cloneable`和`RandomAccess`接口。 ArrayList的内部实现是一个Object类型的数组`elementData`，用于存储列表中的...
ArrayList详解和使用示例_动力节点Java学院整理
08-30
它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。ArrayList提供了相关的添加、删除、修改、遍历等功能。 ArrayList的继承关系 ArrayList继承于AbstractList，实现了...
ArrayList详解，底层是数组，实现Serializable接口
weixin_38166557的博客
07-15 333
一、对于ArrayList需要掌握的七点内容 ArrayList的创建：即构造器往ArrayList中添加对象：即add(E)方法获取ArrayList中的单个对象：即get(int index)方法删除ArrayList中的对象：即remove(E)方法遍历ArrayList中的对象：即iterator，在实际中更常用的是增强型的for循环去做遍历判断对象是否存在于ArrayL...
ArrayList源码分析——如何实现Serializable
gaohe7091的专栏
04-29 626
出处：http://java-road-126-com.iteye.com/blog/1463313   首先，序列化的实现方式:实现Serializable；如果提供了writeObject方法，就会在序列化的时候执行这个方法。看看ArrayList有是如何实现这个方法的。从如下源码中，很容易看到的一点是循环时i Java代码   private void writeObj
Java进阶：深入理解ArrayList实现原理
06-27 173
ArrayList简介ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了Collection和List接口，可以灵活的设置数组的大小。要注意的是ArrayList并不是线程安全的，因此一般建议在单线程中使用ArrayList。ArrayList的继承关系public class ArrayList<E&...
以ArrayList为例学习序列化和反序列化
Jewel’s blog
03-24 2032
一、序列化和反序列化： 在进行对象操作类的实现时，涉及到好几个关键词Serializabletransient 什么是序列化和反序列化？ 序列化：将对象转化为字节的过程称为序列化过程 （存储到本地磁盘） 反序列化：将字节转化为对象过程称为反序列化过程 （从本地磁盘读取对象） 序列化应用场景：网络传输 和 数据存储 序列化的作用： ①数据在网络传输中，对敏感数据不进行传输需要序列...
jdk源码之ArrayList实现Cloneable空架子
m0_58532927的博客
10-24 200
1,ArrayList类图实现了Cloneable对象可以支持clone功能1.Java对象要支持clone功能。但不是所有Java对象都应该可以clone，而是要让用户自己标记出哪些类是可以clone的2.clone()是一个特殊的多态操作，最好是有JVM的直接支持。
Java 集合系列： ArrayList源码深入解析
weixin_33734785的博客
05-07 112
概要 上一章，我们学习了Collection的架构。这一章开始，我们对Collection的具体实现类进行讲解；首先，讲解List，而List中ArrayList又最为常用。因此，本章我们讲解ArrayList。先对ArrayList有个整体认识，再学习它的源码，最后再通过例子来学习如何使用它。 第1部分 ArrayList介绍 ArrayList简介 ArrayList 是一个数组队列，相当于 ...
[集合类] 源码解析1(Iterable、RandomAccess、Serializable、Cloneable）
sougou_1323的博客
11-26 294
集合类是我们每天都在使用的工具。工欲善其事，必先利其器。下面我们从源码的角度来看看集合类中的奥秘。 1. 整体 下面图片是整体的架构，这里只表现了类和接口类的继承实现关系，选取了平时使用比较多的类，如LinkedList、ArrayList、HashMap、TreeMap等，没有考虑并发容器。集合类分为两个体系，Collection和Map。我们先看Collection。 1）Collection...
ArrayList和LinkedList源码解析（一）（三大标记型接口）
weixin_44324174的博客
04-15 453
一、源码分析前的知识补充 1、Serializable标记型接口 （1）介绍 类的序列化由实现java.io.Serializable接口的类启用，不实现此接口的类将不会使任何状态序列化或反序列化。可序列化的所有子类型都是可序列化的。 序列化：将对象的数据写入到文件 反序列化：将对象中的数据读取出来。 （2）代码演示 package com.集合.ArrayList; import java...
泛型机制在Apla-Java系统中的实现与效率提升研究
在Java中，泛型机制主要通过类型参数来实现，允许开发者在类、接口和方法中使用类型参数，以达到类型安全和代码复用的目的。然而，这种类型的泛型机制相对简单，通常只允许一种类型作为参数。少数语言可能还支持子...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值