【设计模式】原型模式：如何快速的克隆出一个对象

最新推荐文章于 2024-06-07 23:58:10 发布
最新推荐文章于 2024-06-07 23:58:10 发布
阅读量1k 收藏
点赞数 1
分类专栏： 程序员 文章标签： 面试 java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64205605/article/details/121442451
版权

BlogStats blogStats = entry.getValue();

if(blogStats.getStatus() == 0){

changeDatas.put(id,blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后=====================”);

print(mapCache);

}

private static void print( Map<Integer, BlogStats> map ){

for(Map.Entry<Integer, BlogStats> entry : map.entrySet()){

System.out.println(“key:”+entry.getKey()+" value:"+entry.getValue());

}

}

}

这是改造之后的代码，解释一下上面的代码，

第一：我不在往数据库中获取所有的博客数据，而是通过一个字段status表示这条记录是否更新过，只查询需要更新的博客信息即可。

第二：再修改的时候需要判断再数据库中查询出来的数据是否在内存中存在，如果存在，执行修改操作，如果不存在，执行添加操作。

按照上面的思路，我们的运行结果应该是博客id在0-7的信息无变化，博客id在8-9被修改，博客id等于10的被新增，那结果是不是这样呢？我们直接来看运行结果

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

更新过后=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

Process finished with exit code 0

从打印的结果来看，id在0-7的没有发生改变，8-9发生了改变，并且新增了一条id为10的新数据，所以这次的改造时成功的，现在已经优化的很好的，但还没有使用到设计模式中的原型模式，那我们还有必要使用吗？

我们之前的操作是直接基于成员变量mapCache，但是我们现在需求稍微做了一下改动，我现在希望，我们需要一次性计算好结果在替换掉成员变量mapCache，而不是一次一次的替换

【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】

浏览器打开：qq.cn.hn/FTf 开源分享

，所以这个时候上面的这种方法就不行了，out了，那我们应该怎么办呢？很多人都想到了

  • 第一步：从数据库中获取到status = 1 的所有数据，也就是已经更新过的数据，这个数据和内存中的一样。

  • 第二步：查询出status=0的所有数据，也就是没有更新过的数据。

  • 第三步：新建一个map用于计算修改后的结果。

  • 第四步：将新建的map替换掉成员变量mapCache。

这样基本上就大功告成了，但是你发现一个问题没有，那就是在第一步的时候会耗费大量的时间，为什么这么说呢？如果数据量过大，HashMap的存储是需要进行hash的计算以及还有可能发生的hash碰撞，所以对象的创建会耗费大量的时间，我们的内存中又存在着一份和我们数据库中差不多的数据，为什么我们不使用它来进行操作呢？这个时候你可能疑惑了，不是说不能对他进行修改吗，要等所有数据修改完成之后一次性替换吗？这个时候原型模式就要上场了。

原型模式两大数据拷贝

=========================================================================

不知道大家有没有听过这句话，new出来的在堆里，引用的在栈中，那我们一起来看看Java的两种拷贝模式，浅拷贝和深拷贝。

浅拷贝

浅拷贝就是拷贝指向对象的指针（java中的引用地址），意思就是说：拷贝出来的目标对象的指针和源对象的指针指向的内存空间是同一块空间，浅拷贝只是一种简单的拷贝，让几个对象公用一个内存，然而当内存销毁的时候，指向这个内存空间的所有指针需要重新定义，不然会造成野指针错误。

我们来画个图说明一下，算了，不画了，实在找不到比较好的画图工具，画的太难看了，还不如直接讲，如果有好的画图工具，可以评论告诉我哦，十分感谢。

通俗一点来说，浅拷贝就是拷贝数据的引用地址，并没有拷贝真正的数据，也就是说，拷贝出来的对象和原始对象共享一套数据，也就是说拷贝的数据发生改变，原数据也会发生改变，原数据发生改变，拷贝的数据也会发生改变，因为他们共享一套数据。

下面我们使用浅拷贝来实现一下我们上面的demo，由于Map是没有clone()方法的，所以我需要将之前的Map改成HashMap，请看demo

package com.ymy.test;

import com.ymy.entity.BlogStats;

import java.util.HashMap;

import java.util.Map;

public class PrototypeDesignPattern {

/**

  • 内存中存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapCache = new HashMap<Integer, BlogStats>();

/**

  • 数据库存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapMysql = new HashMap<Integer, BlogStats>();

/**

  • 最近一次的修改时间

*/

private static Long updateTime = 1585882804208L;

static {

BlogStats blogStats = null;

//初始化内存中java的博客信息

for(int i = 0; i< 10 ;++i){

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言”+i)

.likeNum(i)

.viewNum(i)

.commentNum(i)

.status(1)

.build();

mapCache.put(i,blogStats);

}

//初始化数据库中java的博客信息

for(int i = 0; i<= 10 ;++i){

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言”+i)

.likeNum(i+2)

.viewNum(i+2)

.commentNum(i+2)

.status(i >= 8 ? 0 : 1)

.build();

mapMysql.put(i,blogStats);

}

}

/**

  • 每天定时更新

*/

private static void update(Map<Integer, BlogStats> changeData){

//这是浅拷贝

HashMap<Integer,BlogStats> oldData = (HashMap<Integer, BlogStats>) mapCache.clone();

for(Map.Entry<Integer, BlogStats> entry : changeData.entrySet()){

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

blogStats.setStatus(1);

if(oldData.containsKey(id)){

BlogStats bs = oldData.get(id);

bs.setLikeNum(blogStats.getLikeNum());

bs.setViewNum(blogStats.getViewNum());

bs.setCommentNum(blogStats.getCommentNum());

}else{

oldData.put(id,blogStats);

}

}

System.out.println(“克隆的HashMap最终结果如下=====================”);

print(oldData);

System.out.println(“克隆对象修改完成之后，原数据如下================”);

print(mapCache);

mapCache = oldData;

}

/**

  • 根据更新的状态获取到最新需要修改的数据

  • 由于这里仅仅只是模拟，所以这里我就随便造几条数据，你们主要看思想即可

  • @return

*/

public static Map<Integer,BlogStats> getChangeData(){

//在数据库中查询还没有更新过的数据

//由于我是模拟，所以我直接伪造了几条数据充当需要修改的数据，还请见谅

Map<Integer,BlogStats> changeDatas= new HashMap<Integer,BlogStats>();

for(Map.Entry<Integer, BlogStats> entry : mapMysql.entrySet()){

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

if(blogStats.getStatus() == 0){

changeDatas.put(id,blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

System.out.println(“内存中最开始存在的数据”);

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后内存中的数据=====================”);

print(mapCache);

}

private static void print( Map<Integer, BlogStats> map ){

for(Map.Entry<Integer, BlogStats> entry : map.entrySet()){

System.out.println(“key:”+entry.getKey()+" value:"+entry.getValue());

}

}

}

这里面做的修改就是使用了一个局部变量oldData接收mapCache克隆结果，然后对克隆的结果做修改，代码中使用的mapCache.clone()属于浅拷贝，之前说过浅拷贝的数据是共享的，那我们对拷贝过后的数据进行修改，那原数据会不会受到影响呢？我们一起看打印结果

内存中最开始存在的数据

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

克隆的HashMap最终结果如下=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

克隆对象修改完成之后，原数据如下================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

更新过后内存中的数据=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

Process finished with exit code 0

我们来看：克隆的HashMap最终结果如下=====================

在这里插入图片描述

修改了两行，新增了一行，从上面的打印结果可以看出原数据也发生了相应的变化

在这里插入图片描述

虽然克隆对象中新增的对象没有在原对象中增加，但是修改的属性在原对象中也发生了改变，使用浅拷贝的同学一定要注意这一点。

所以浅拷贝就不能实现我们的需求了，前面还有一个深拷贝还没有说，那它能不能满足我们的要求 呢？

深拷贝

一个引用对象一般来说由两个部分组成：一个具名的Handle，也就是我们所说的声明（如变量）和一个内部（不具名）的对象，也就是具名Handle的内部对象。它在Manged Heap（托管堆）中分配，一般由新增引用对象的New方法是进行创建。深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人名叫张三，后来用他克隆（假设法律允许）了另外一个人，叫李四，不管是张三缺胳膊少腿还是李四缺胳膊少腿都不会影响另外一个人。比较典型的就是Value（值）对象，如预定义类型Int32，Double，以及结构（struct），枚举（Enum）等。

根据介绍来说，深度拷贝是可以满足我们需求的，那我们因该如何实现深拷贝呢？

序列化

序列化很好理解，就是将对象序列化，然后再反序列化，这两步之后就会得到一个全新的对象。

核心代码

/**

  • 深拷贝

  • @param obj

  • @return

*/

private static Object deepColne(Object obj) {

try {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return objectInputStream.readObject();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return null;

}

这个就是通过序列化再反序列化的核心代码，然后再看一下完整demo

package com.ymy.test;

import com.ymy.entity.BlogStats;

import java.io.*;

import java.util.HashMap;

import java.util.Map;

public class PrototypeDesignPattern {

/**

  • 内存中存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapCache = new HashMap<Integer, BlogStats>();

/**

  • 数据库存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapMysql = new HashMap<Integer, BlogStats>();

/**

  • 最近一次的修改时间

*/

private static Long updateTime = 1585882804208L;

static {

BlogStats blogStats = null;

//初始化内存中java的博客信息

for (int i = 0; i < 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i)

.viewNum(i)

.commentNum(i)

.status(1)

.build();

mapCache.put(i, blogStats);

}

//初始化数据库中java的博客信息

for (int i = 0; i <= 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i + 2)

.viewNum(i + 2)

.commentNum(i + 2)

.status(i >= 8 ? 0 : 1)

.build();

mapMysql.put(i, blogStats);

}

}

/**

  • 每天定时更新

*/

private static void update(Map<Integer, BlogStats> changeData) {

//这是浅拷贝

HashMap<Integer, BlogStats> oldData = (HashMap<Integer, BlogStats>) deepColne(mapCache);

for (Map.Entry<Integer, BlogStats> entry : changeData.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

blogStats.setStatus(1);

if (oldData.containsKey(id)) {

BlogStats bs = oldData.get(id);

bs.setLikeNum(blogStats.getLikeNum());

bs.setViewNum(blogStats.getViewNum());

bs.setCommentNum(blogStats.getCommentNum());

} else {

oldData.put(id, blogStats);

}

}

System.out.println(“克隆的HashMap最终结果如下=====================”);

print(oldData);

System.out.println(“克隆对象修改完成之后，原数据如下================”);

print(mapCache);

mapCache = oldData;

}

/**

  • 根据更新的状态获取到最新需要修改的数据

  • 由于这里仅仅只是模拟，所以这里我就随便造几条数据，你们主要看思想即可

  • @return

*/

public static Map<Integer, BlogStats> getChangeData() {

//在数据库中查询还没有更新过的数据

//由于我是模拟，所以我直接伪造了几条数据充当需要修改的数据，还请见谅

Map<Integer, BlogStats> changeDatas = new HashMap<Integer, BlogStats>();

for (Map.Entry<Integer, BlogStats> entry : mapMysql.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

if (blogStats.getStatus() == 0) {

changeDatas.put(id, blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

System.out.println(“内存中最开始存在的数据”);

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后内存中的数据=====================”);

print(mapCache);

}

/**

  • 深拷贝

  • @param obj

  • @return

*/

private static Object deepColne(Object obj) {

try {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return objectInputStream.readObject();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return null;

}

private static void print(Map<Integer, BlogStats> map) {

for (Map.Entry<Integer, BlogStats> entry : map.entrySet()) {

System.out.println(“key:” + entry.getKey() + " value:" + entry.getValue());

}

}

}

与浅拷贝相比，改动的地方并不多，只有克隆的地方发生了修改，其他地方不变

内存中最开始存在的数据

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

克隆的HashMap最终结果如下=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

克隆对象修改完成之后，原数据如下================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=8, viewNum=8, commentNum=8, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=9, viewNum=9, commentNum=9, status=1)

更新过后内存中的数据=====================

key:0 value:BlogStats(id=0, title=java是世界上最好的语言0, likeNum=0, viewNum=0, commentNum=0, status=1)

key:1 value:BlogStats(id=1, title=java是世界上最好的语言1, likeNum=1, viewNum=1, commentNum=1, status=1)

key:2 value:BlogStats(id=2, title=java是世界上最好的语言2, likeNum=2, viewNum=2, commentNum=2, status=1)

key:3 value:BlogStats(id=3, title=java是世界上最好的语言3, likeNum=3, viewNum=3, commentNum=3, status=1)

key:4 value:BlogStats(id=4, title=java是世界上最好的语言4, likeNum=4, viewNum=4, commentNum=4, status=1)

key:5 value:BlogStats(id=5, title=java是世界上最好的语言5, likeNum=5, viewNum=5, commentNum=5, status=1)

key:6 value:BlogStats(id=6, title=java是世界上最好的语言6, likeNum=6, viewNum=6, commentNum=6, status=1)

key:7 value:BlogStats(id=7, title=java是世界上最好的语言7, likeNum=7, viewNum=7, commentNum=7, status=1)

key:8 value:BlogStats(id=8, title=java是世界上最好的语言8, likeNum=10, viewNum=10, commentNum=10, status=1)

key:9 value:BlogStats(id=9, title=java是世界上最好的语言9, likeNum=11, viewNum=11, commentNum=11, status=1)

key:10 value:BlogStats(id=10, title=java是世界上最好的语言10, likeNum=12, viewNum=12, commentNum=12, status=1)

Process finished with exit code 0

这个时候我们发现，即使拷贝的数据发生了变化，原始数据还是原来的数据，这就是深度拷贝，深度拷贝有一个比较致命的缺点，那就是拷贝的时间太长，因为它不仅需要拷贝引用，同时还需要拷贝数据，相对于浅拷贝而言效率太差，当然深拷贝的实现方式不止这一种，还有很多，我在这里就不做过多的展示了。

这里有一点需要特别注意，深度拷贝的对象需要实现序列化，也就是：

在这里插入图片描述

否则会导致程序报错。

既然浅拷贝会导致数据共享，深拷贝印象对象创建的效率，那我们有没有一种这种的方案来解决上面的这个问题呢？可以先想一想，不要着急看下面，因为下面肯定有答案，没有的话我也肯定不会让你们想的。

浅拷贝+深拷贝

对于上面的需求来说，我们需要修改发生改变的博客信息，但是需要修改的数据并不是很多，可能只有几条，也有可能只有几十条，再几十万数据中修改几条使用深拷贝就有点过粪了，所以这里我们采用一种比较折中的方式：浅拷贝+深拷贝。

如何实现呢？我们首先将所有的数据心境浅拷贝，然后遇到需要修改的数据再进行深拷贝即可。

改造代码

package com.ymy.test;

import com.ymy.entity.BlogStats;

import java.io.*;

import java.util.HashMap;

import java.util.Map;

public class PrototypeDesignPattern {

/**

  • 内存中存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapCache = new HashMap<Integer, BlogStats>();

/**

  • 数据库存放的数据

  • key：博客id

  • value：博客信息

*/

private static HashMap<Integer, BlogStats> mapMysql = new HashMap<Integer, BlogStats>();

/**

  • 最近一次的修改时间

*/

private static Long updateTime = 1585882804208L;

static {

BlogStats blogStats = null;

//初始化内存中java的博客信息

for (int i = 0; i < 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i)

.viewNum(i)

.commentNum(i)

.status(1)

.build();

mapCache.put(i, blogStats);

}

//初始化数据库中java的博客信息

for (int i = 0; i <= 10; ++i) {

blogStats = BlogStats.builder()

.id(i)

.title(“java是世界上最好的语言” + i)

.likeNum(i + 2)

.viewNum(i + 2)

.commentNum(i + 2)

.status(i >= 8 ? 0 : 1)

.build();

mapMysql.put(i, blogStats);

}

}

/**

  • 每天定时更新

*/

private static void update(Map<Integer, BlogStats> changeData) {

//这是浅拷贝

HashMap<Integer, BlogStats> oldData = (HashMap<Integer, BlogStats>) mapCache.clone();

for (Map.Entry<Integer, BlogStats> entry : changeData.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

blogStats.setStatus(1);

if (oldData.containsKey(id)) {

//我们先删除数据，因为浅拷贝对删除/新增是不会改变原数据的属性的

oldData.remove(id);

}

//这里再重新赋值

oldData.put(id,blogStats);

}

System.out.println(“克隆的HashMap最终结果如下=====================”);

print(oldData);

System.out.println(“克隆对象修改完成之后，原数据如下================”);

print(mapCache);

mapCache = oldData;

}

/**

  • 根据更新的状态获取到最新需要修改的数据

  • 由于这里仅仅只是模拟，所以这里我就随便造几条数据，你们主要看思想即可

  • @return

*/

public static Map<Integer, BlogStats> getChangeData() {

//在数据库中查询还没有更新过的数据

//由于我是模拟，所以我直接伪造了几条数据充当需要修改的数据，还请见谅

Map<Integer, BlogStats> changeDatas = new HashMap<Integer, BlogStats>();

for (Map.Entry<Integer, BlogStats> entry : mapMysql.entrySet()) {

Integer id = entry.getKey();

BlogStats blogStats = entry.getValue();

if (blogStats.getStatus() == 0) {

changeDatas.put(id, blogStats);

}

}

return changeDatas;

}

public static void main(String[] args) {

System.out.println(“内存中最开始存在的数据”);

print(mapCache);

//获取修改的数据

Map<Integer, BlogStats> changeData = getChangeData();

//更新内存数据

update(changeData);

//将修改的博客状态改为1并写回数据库，这段省略

System.out.println(“更新过后内存中的数据=====================”);

print(mapCache);

}

/**

  • 深拷贝

  • @param obj

  • @return

*/

private static Object deepColne(Object obj) {

try {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return objectInputStream.readObject();

} catch (IOException e) {

Huawei开源分享
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】
03-31
java设计模式【之】原型模式、深拷贝与浅拷贝【源码】【场景：克隆羊】 * 原型模式(Prototype) * 实现方式： * 需要被克隆的 class类， 重写Object中的clone()方法，并实现Cloneable接口（否则报错 ...
Java设计模式——原型模式
01-20
原型模式Java设计模式——原型模式概念使用场景Java里的克隆代码理解prototype(原型)问题总结优缺点模型优点模型缺点 概念 ​ 原型模式是创建型模式的最后一种，讲到原型模式就不得不提到克隆这个词，克隆这个词...
【设计模式】原型模式：如何快速的克隆出一个对象？
流星007
04-03 1362
当面试官问你：对象创建过程过于复杂的时候你会怎么办？你就把这篇文章扔给面试官就对了，绝对加分！
设计模式 - 原型模式 - 浅克隆和深克隆
烟溪彭于晏的博客
07-19 350
原型（Prototype）模式的定义如下用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。Java自带的原型模式基于内存二进制流的复制，在性能上比直接new一个对象更加优良。需要为每一个类都配置一个clone方法。...
java设计模式——原型模式之浅克隆
weixin_43592833的博客
10-31 283
原型模式概述：通过复制一个实例（原型）来创建新的对象。使用场景：对象实例化创建过程比较复杂时，可以复制一个新的对象，在复制对象的基础上改变属性。
介绍原型模式：快速构建和复制对象的设计模式
ALex_zry的博客
08-17 457
原型模式是一种快速构建和复制对象的设计模式。通过克隆现有对象来创建新对象，原型模式提供了一种高效且灵活的对象创建方式。它适用于需要频繁创建和复制对象的场景，并能够动态地改变对象的状态。然而，在使用原型模式时，需要注意管理和维护复杂对象关系的困难性。如有任何问题或疑问，请随时与我们联系。推荐一个零声学院免费教程，个人觉得老师讲得不错， 服务器课程。
原型模式——对象的克隆
布道师小羊的博客
07-27 918
一起走进原型模式的世界吧！
C++设计模式：原型模式
ajbb093的博客
04-07 850
在本案例中，如果对史莱姆的原型进行克隆，也就是分裂成不同的对象，而不同的史莱姆型号会对应着不同的技能，假设大型史莱姆是撞击，普通史莱姆是喷射，小型史莱姆是自爆，则简单地进行深克隆以及浅克隆可能会引起异常。因此，对此的解决办法便是原型模式结合状态模式使用，状态模式是指在软件构建过程中，某些对象的状态如果发生改变，其行为也会随之发生变化，使用状态模式将能允许一个对象在其内部状态发生改变时改变它的行为，从而使对象看起来似乎修改了其行为。，普通史莱姆转换成小型史莱姆，其中四只转换后的小型史莱姆共享血量（
原型(克隆)模式
Filwaod
11-29 1378
原型模式的重心还是在创建新的对象实例，至于创建出来的对象，其属性的值是否一定要和原型对象属性的值完全一样，这个并没有强制规定，只不过在目前大多数实现中，克隆出来的对象和原型对象的属性值是一样的。原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。克隆是手段，目的是生成新的对象实例。原型模式的客户端只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类型的依赖。
设计模式--克隆模式（原型模式）
你好师姐！
02-05 808
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少...
设计模式-原型模式实例-02-深克隆
LYly_B的博客
03-12 373
设计模式-原型模式实例-深克隆 浅克隆与深克隆： 浅克隆： 当对象被复制时，只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量未被复制。(Object.clone()方法) 深克隆： 对象本身及其包含的所有成员变量也将被复制。 (序列化，通过序列化对象将对象写到一个流中，再从流中读出来。原型必须实现Serializable接口(空接口/标识接口)，才能序列化。) 注意： x.clon...
原型模式（深克隆、浅克隆）
weixin_51201930的博客
04-23 2274
文章目录前言一、原型模式定义二、原型模式的结构与实现三、案例 前言 一、原型模式定义 原型模式是一种创建型设计模式，Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。 二、原型模式的结构与实现 原型模式有以下三种角色： 1.抽象原型类：规定了具体原型对象必须实现的接口。 2.具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对
PHP设计模式之原型设计模式原理与用法分析
01-20
本文实例讲述了PHP设计模式之原型设计模式原理与用法。分享给大家供大家参考，...如果一个项目要求你创建某个原型对象的多个实例，就可以使用原型设计模式。 三、原型设计模式实例 这里以现代企业组织为例： <?ph
Android编程设计模式之原型模式实例详解
01-20
原型二字表明了该模型应该有一个样板实例，用户从这个样板对象中复制出一个内部属性一致的对象，这个过程也就是我们俗称的“克隆”。被复制的实例就是我们所称的“原型”，这个原型也是可定制的。原型模型多用于创建...
C# 设计模式系列教程-原型模式
01-21
　2.1 抽象原型类（Abstract Prototype）：提供一个克隆接口 　2.2 具体原型类（Concrete Prototype）: 及实现了克隆接口的具体原型类 3. 实例：求职网站上现在都支持多份简历，如果每创建一份简历都要从头至尾地...
面试高频问题----2
chenDR333的博客
06-04 471
4.线程切换的开销比进程的开销小，因为操作系统只需要保存和加载线程的上下文，而不需要保存和加载整个进程的上下文。2.最大线程数：线程池中允许的最大线程数。3.空闲线程的存活时间：当线程池中的线程数量超过核心线程数时，多余的空闲线程在终止之前等待新任务的最长时间。6.线程工厂：用于创建新线程的工厂，可以自定义线程的创建方式，比如设置线程名称，线程优先级。1.核心线程数：线程池中保持存活的最小线程数，即使它们处于空闲状态也不会被销毁。线程：1.线程是操作系统调度的基本单位，但它是进程内的执行流。
【前端面试常见问题】如何实现一个元素的水平垂直居中
c_wengy的博客
06-03 289
在网页设计中，将元素精准地置于容器的中心位置是一项基础且常用的技术。也是前端面试中常见的问题之一，如果能在面试中作出更全面的回答也会提高对你的评分。
6.算法讲解之-面试题中位运算的妙用1
yzc的博客
06-03 788
面试题中位运算的妙用
2024.6.7学习记录
最新发布
m0_74989367的博客
06-07 193
1、css面试题复习加整理。
java设计模式中原型模式，浅克隆和深克隆的区别
05-13
原型模式是一种创建型设计模式，它允许对象在不知道其具体类型的情况下被复制。在 Java 中，对象的复制通常是通过克隆来完成的。具体来说，原型模式可以分为浅克隆和深克隆。 浅克隆是指只复制对象本身，而不复制对象内部的引用类型属性。也就是说，浅克隆复制的是对象的引用，而不是对象本身。如果原型对象的属性是基本数据类型，则在浅克隆时会直接复制这些属性的值；如果属性是引用类型，则复制的是这些属性的引用，也就是说，原型对象和克隆对象共享同一个引用对象。 深克隆是指不仅复制对象本身，还要复制对象内部的引用类型属性。也就是说，深克隆会递归地复制对象内部的所有引用类型属性，直到所有引用类型属性都是基本数据类型或者不可变对象为止。 在实际应用中，要根据具体的需求来选择浅克隆或深克隆。如果原型对象的引用类型属性是不可变的，则可以选择浅克隆；如果引用类型属性是可变的，则必须选择深克隆，以避免克隆对象和原型对象共享同一个引用对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值