通过与C++程序对比，彻底搞清楚JAVA的对象拷贝
目录
一、背景
JAVA编程中的对象一般都是通过new进行创建的，新创建的对象通常是初始化的状态，但当这个对象某些属性产生变更，且要求用一个对象副本来保存当前对象的“状态”，这时候就需要用到对象拷贝的功能，以便封装对象之间的快速克隆。
二、JAVA对象拷贝的实现
2.1 浅拷贝
- 被复制的类需要实现Clonenable接口；
- 覆盖clone()方法，调用super.clone()方法得到需要的复制对象；
- 浅拷贝对基本类型(boolean,char,byte,short,float,double.long)能完成自身的复制，但对于引用类型只对引用地址进行拷贝。
-- 下面我们用一个实例进行验证：
/**
* 单只牌
*
* @author zhuhuix
* @date 2020-06-10
*/
public class Card implements Comparable, Serializable,Cloneable {
// 花色
private String color = "";
//数字
private String number = "";
public Card() {
}
public Card(String color, String number) {
this.color = color;
this.number = number;
}
public String getColor() {
return this.color;
}
public void setColor(String color) {
this.color = color;
}
public String getNumber() {
return this.number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public String toString() {
return this.color + this.number;
}
@Override
public int compareTo(Object o) {
if (o instanceof Card) {
int thisColorIndex = Constant.COLORS.indexOf(this.getColor());
int anotherColorIndex = Constant.COLORS.indexOf(((Card) o).getColor());
int thisNumberIndex = Constant.NUMBERS.indexOf(this.getNumber());
int anotherNumberIndex = Constant.NUMBERS.indexOf(((Card) o).getNumber());
// 大小王之间相互比较: 大王大于小王
if ("JOKER".equals(this.color) && "JOKER".equals(((Card) o).getColor())) {
return thisColorIndex > anotherColorIndex ? 1 : -1;
}
// 大小王与数字牌之间相互比较：大小王大于数字牌
if ("JOKER".equals(this.color) && !"JOKER".equals(((Card) o).getColor())) {
return 1;
}
if (!"JOKER".equals(this.color) && "JOKER".equals(((Card) o).getColor())) {
return -1;
}
// 数字牌之间相互比较: 数字不相等，数字大则牌面大；数字相等 ，花色大则牌面大
if (thisNumberIndex == anotherNumberIndex) {
return thisColorIndex > anotherColorIndex ? 1 : -1;
} else {
return thisNumberIndex > anotherNumberIndex ? 1 : -1;
}
} else {
return -1;
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/**
* 扑克牌常量定义
*
* @author zhuhuix
* @date 2020-06-10
*/
public class Constant {
// 纸牌花色：黑桃，红心，梅花，方块
final static List<String> COLORS = new ArrayList<>(
Arrays.asList(new String[]{"♢", "", "♡", ""}));
// 纸牌数字
final static List<String> NUMBERS = new ArrayList<>(
Arrays.asList(new String[]{"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"}));
// 大王小王
final static List<String> JOKER = new ArrayList<>(
Arrays.asList(new String[]{"小王","大王"}));
}
/**
* 整副副扑克牌
*
* @author zhuhuix
* @date 2020-06-10
*/
public class Poker implements Cloneable, Serializable {
private List<Card> cards;
public Poker() {
List<Card> cardList = new ArrayList<>();
// 按花色与数字组合生成52张扑克牌
for (int i = 0; i < Constant.COLORS.size(); i++) {
for (int j = 0; j < Constant.NUMBERS.size(); j++) {
cardList.add(new Card(Constant.COLORS.get(i), Constant.NUMBERS.get(j)));
}
}
// 生成大小王
for (int i = 0; i < Constant.JOKER.size(); i++) {
cardList.add(new Card("JOKER", Constant.JOKER.get(i)));
}
this.cards = cardList;
}
// 从整副扑克牌中抽走大小王
public void removeJoker() {
Iterator<Card> iterator = this.cards.iterator();
while (iterator.hasNext()) {
Card cardJoker = iterator.next();
if (cardJoker.getColor() == "JOKER") {
iterator.remove();
}
}
}
public List<Card> getCards() {
return cards;
}
public void setCards(List<Card> cards) {
this.cards = cards;
}
public Integer getCardCount() {
return this.cards.size();
}
@Override
public String toString() {
StringBuilder poker = new StringBuilder("[");
Iterator<Card> iterator = this.cards.iterator();
while (iterator.hasNext()) {
poker.append(iterator.next().toString() + ",");
}
poker.setCharAt(poker.length() - 1, ']');
return poker.toString();
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/**
* 测试程序
*
* @author zhuhuix
* @date 2020-6-10
*/
public class PlayDemo {
public static void main(String[] args) throws CloneNotSupportedException {
// 生成一副扑克牌并洗好牌
Poker poker1 = new Poker();
System.out.println("新建：第一副牌共 "+poker1.getCardCount()+" 张:"+poker1.toString());
Poker poker2= (Poker) poker1.clone();
System.out.println("第一副牌拷页生成第二副牌，共 "+poker2.getCardCount()+" 张:"+poker2.toString());
poker1.removeJoker();
System.out.println("====第一副牌抽走大小王后====");
System.out.println("第一副牌还有 "+poker1.getCardCount()+" 张:"+poker1.toString());
System.out.println("第二副牌还有 "+poker2.getCardCount()+" 张:"+poker2.toString());
}
}
- 运行结果：
-- 在第一副的对象中抽走了“大小王”，克隆的第二副的对象的“大小王”竟然也被“抽走了”
2.2 深拷贝的实现方法一
- 被复制的类需要实现Clonenable接口；
- 覆盖clone()方法，自主实现引用类型成员的拷贝复制。
-- 我们只要改写一下Poker类中的clone方法，让引用类型成员实现复制：
/**
* 整副副扑克牌--自主实现引用变量的复制
*
* @author zhuhuix
* @date 2020-06-10
*/
public class Poker implements Cloneable, Serializable {
private List<Card> cards;
public Poker() {
List<Card> cardList = new ArrayList<>();
// 按花色与数字组合生成52张扑克牌
for (int i = 0; i < Constant.COLORS.size(); i++) {
for (int j = 0; j < Constant.NUMBERS.size(); j++) {
cardList.add(new Card(Constant.COLORS.get(i), Constant.NUMBERS.get(j)));
}
}
// 生成大小王
for (int i = 0; i < Constant.JOKER.size(); i++) {
cardList.add(new Card("JOKER", Constant.JOKER.get(i)));
}
this.cards = cardList;
}
// 从整副扑克牌中抽走大小王
public void removeJoker() {
Iterator<Card> iterator = this.cards.iterator();
while (iterator.hasNext()) {
Card cardJoker = iterator.next();
if (cardJoker.getColor() == "JOKER") {
iterator.remove();
}
}
}
public List<Card> getCards() {
return cards;
}
public void setCards(List<Card> cards) {
this.cards = cards;
}
public Integer getCardCount() {
return this.cards.size();
}
@Override
public String toString() {
StringBuilder poker = new StringBuilder("[");
Iterator<Card> iterator = this.cards.iterator();
while (iterator.hasNext()) {
poker.append(iterator.next().toString() + ",");
}
poker.setCharAt(poker.length() - 1, ']');
return poker.toString();
}
// 遍历原始对象的集合，对生成的对象进行集合复制
@Override
protected Object clone() throws CloneNotSupportedException {
Poker newPoker = (Poker)super.clone();
newPoker.cards = new ArrayList<>();
newPoker.cards.addAll(this.cards);
return newPoker;
}
}
- 输出结果：
-- 通过自主实现引用类型的复制，原对象与对象的拷贝的引用类型成员地址不再关联
2.3 深拷贝的实现方法二
- 在用第二种方式实现JAVA深拷贝之前，我们首先对C++程序的对象拷贝做个了解：
2.3.1 C++拷贝构造函数
C++拷贝构造函数，它只有一个参数，参数类型是本类的引用，且一般用const修饰
2.3.2 C++源码
// 单只牌的类定义
// Created by Administrator on 2020-06-10.
//
#ifndef _CARD_H
#define _CARD_H
#include <string>
using namespace std;
class Card {
private :
string color;
string number;
public:
Card();
Card(const string &color, const string &number);
const string &getColor() const;
void setColor(const string &color);
const string &getNumber() const;
void setNumber(const string &number);
string toString();
};
#endif //_CARD_H
// 单只牌类的实现
// Created by Administrator on 2020-06-10.
//
#include "card.h"
Card::Card(){}
Card::Card(const string &color, const string &number) : color(color), number(number) {}
const string &Card::getColor() const {
return color;
}
void Card::setColor(const string &color) {
Card::color = color;
}
const string &Card::getNumber() const {
return number;
}
void Card::setNumber(const string &number) {
Card::number = number;
}
string Card::toString() {
return getColor()+getNumber();
}
// 扑克牌类的定义
// Created by Administrator on 2020-06-10.
//
#ifndef _POKER_H
#define _POKER_H
#include <vector>
#include "card.h"
using namespace std;
const int COLOR_COUNT=4;
const int NUMBER_COUNT=13;
const int JOKER_COUNT=2;
const string COLORS[COLOR_COUNT] = {"♢", "", "♡", ""};
const string NUMBERS[NUMBER_COUNT]={"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
const string JOKER[JOKER_COUNT] ={"小王","大王"};
class Poker {
private:
vector<Card> cards;
public:
Poker();
Poker(const Poker &poker);
const vector<Card> &getCards() const;
void setCards(const vector<Card> &cards);
int getCardCount();
void toString();
void clear();
};
#endif //_POKER_H
// 扑克牌类的实现
// Created by zhuhuix on 2020-06-10.
//
#include "Poker.h"
#include <iostream>
const vector<Card> &Poker::getCards() const {
return this->cards;
}
void Poker::setCards(const vector<Card> &cards) {
Poker::cards = cards;
}
// 构造函数
Poker::Poker() {
for (int i = 0; i < NUMBER_COUNT; i++) {
for (int j = 0; j < COLOR_COUNT; j++) {
this->cards.emplace_back(COLORS[j], NUMBERS[i]);
}
}
for (int i = 0; i < JOKER_COUNT; i++) {
this->cards.emplace_back("JOKER", JOKER[i]);
}
}
// 拷贝构造函数
Poker::Poker(const Poker &poker) {
for (int i = 0; i < poker.getCards().size(); i++) {
this->cards.emplace_back(poker.cards[i].getColor(), poker.cards[i].getNumber());
}
}
int Poker::getCardCount() {
return this->cards.size();
}
void Poker::toString() {
cout << "共" << getCardCount() << "张牌:";
cout << "[";
for (int i = 0; i < this->cards.size(); i++) {
cout << this->cards[i].toString();
if (i != getCardCount() - 1) {
cout << ",";
}
}
cout << "]" << endl;
}
void Poker::clear() {
this->cards.clear();
}
// 主测试程序
// Created by Administrator on 2020-06-10.
//
#include "Poker.h"
#include <iostream>
using namespace std;
int main() {
Poker poker1;
cout << "第一副牌:";
poker1.toString();
// 通过拷贝构造函数生成第二副牌
Poker poker2(poker1);
cout << "第二副牌:";
poker2.toString();
// 清除扑克牌1
poker1.clear();
cout << "清空后，第一副牌:";
poker1.toString();
cout << "第二副牌:";
poker2.toString();
return 0;
}
- 输出：
2.3.3 JAVA通过拷贝构造方法实现深拷贝
- JAVA拷贝构造方法与C++的拷贝构造函数相同，被复制对象的类需要实现拷贝构造方法：
--首先需要声明带有和本类相同类型的参数构造方法
--其次拷贝构造方法可以通过序列化实现快速复制 - 拷贝对象通过调用拷贝构造方法进行创建。
-- 我们再改写一下Poker类，实现拷贝构造方法：
/**
* 整副副扑克牌--实现拷贝构造方法
*
* @author zhuhuix
* @date 2020-06-10
*/
public class Poker implements Serializable {
private List<Card> cards;
public Poker() {
List<Card> cardList = new ArrayList<>();
// 按花色与数字组合生成52张扑克牌
for (int i = 0; i < Constant.COLORS.size(); i++) {
for (int j = 0; j < Constant.NUMBERS.size(); j++) {
cardList.add(new Card(Constant.COLORS.get(i), Constant.NUMBERS.get(j)));
}
}
// 生成大小王
for (int i = 0; i < Constant.JOKER.size(); i++) {
cardList.add(new Card("JOKER", Constant.JOKER.get(i)));
}
this.cards = cardList;
}
// 拷贝构造方法：利用序列化实现深拷贝
public Poker(Poker poker) {
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(os);
oos.writeObject(poker);
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
ObjectInputStream ois = new ObjectInputStream(is);
this.cards = ((Poker) ois.readObject()).getCards();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
// 从整副扑克牌中抽走大小王
public void removeJoker() {
Iterator<Card> iterator = this.cards.iterator();
while (iterator.hasNext()) {
Card cardJoker = iterator.next();
if (cardJoker.getColor() == "JOKER") {
iterator.remove();
}
}
}
public List<Card> getCards() {
return cards;
}
public void setCards(List<Card> cards) {
this.cards = cards;
}
public Integer getCardCount() {
return this.cards.size();
}
@Override
public String toString() {
StringBuilder poker = new StringBuilder("[");
Iterator<Card> iterator = this.cards.iterator();
while (iterator.hasNext()) {
poker.append(iterator.next().toString() + ",");
}
poker.setCharAt(poker.length() - 1, ']');
return poker.toString();
}
}
- 对测试主程序进行修改：
/**
* 测试程序
*
* @author zhuhuix
* @date 2020-6-10
*/
public class PlayDemo {
public static void main(String[] args) throws CloneNotSupportedException {
// 生成一副扑克牌并洗好牌
Poker poker1 = new Poker();
System.out.println("新建：第一副牌共 "+poker1.getCardCount()+" 张:"+poker1.toString());
Poker poker2 = new Poker(poker1);
System.out.println("第一副牌拷页生成第二副牌，共 "+poker2.getCardCount()+" 张:"+poker2.toString());
poker1.removeJoker();
System.out.println("====第一副牌抽走大小王后====");
System.out.println("第一副牌还有 "+poker1.getCardCount()+" 张:"+poker1.toString());
System.out.println("第二副牌还有 "+poker2.getCardCount()+" 张:"+poker2.toString());
Poker poker3 = new Poker(poker1);
System.out.println("第三副牌还有 "+poker3.getCardCount()+" 张:"+poker3.toString());
}
}
- 输出结果：
--通过序列化的有手段，同样也能实现对象的深拷贝
四、总结
- java程序进行对象拷贝时，如果对象的类中存在引用类型时，需进行深拷贝
- 对象拷贝可以通过实现Cloneable接口完成
- java编程也可仿照 C++程序的拷贝构造函数，实现拷贝构造方法进行对象的复制
- 通过序列化与反序化手段可实现对象的深拷贝
通过与C++程序对比，彻底搞清楚JAVA的对象拷贝的更多相关文章
- 一个例子搞清楚Java程序执行顺序
当我们new一个GirlFriend时,我们都做了什么? 一个例子搞懂Java程序运行顺序 public class Girl { Person person = new Person("G ...
- Java面向对象程序设计--与C++对比说明:系列3(Java 继承机制)
继承(inheritance)背后的核心思想是: bonus = b; } } Java没有像C++那样提供多继承机制,但提供了接口机制,在后面我们将详细探究接口机制的实现 ...
- 几周内搞定Java的10个方法
不要将Java与JavaScript弄混了,Java的目标是“一次编译,到处调试”(呃,不对,是“到处运行”).简单来说,就是Java程序可以直接在任何设备上运行. Java语言是什么? 不管我们是否 ...
- 一文彻底搞懂Java中的环境变量
一文搞懂Java环境变量 记得刚接触Java,第一件事就是配环境变量,作为一个初学者,只知道环境变量怎样配,在加上各种IDE使我们能方便的开发,而忽略了其本质的东西,只知其然不知其所以然,随着不断的深 ...
- 程序员必须掌握的Java 框架，小白学会之后15k不是问题
Spring 的核心特性是什么?Spring 优点? Spring 的核心是控制反转(IoC)和面向切面(AOP) Spring 优点: 程序员必须掌握的Java 框架,学会之后50k不是问题 (1) ...
- 从程序员到CTO的Java技术路线图 作者：zz563143188
在技术方面无论我们怎么学习,总感觉需要提升自已不知道自己处于什么水平了.但如果有清晰的指示图供参考还是非常不错的,这样我们清楚的知道我们大概处于那个阶段和水平. Java程序员 高级特性 反射.泛型. ...
- Android应用程序窗口（Activity）的视图对象（View）的创建过程分析
从前文可知道,每一个Activity组件都有一个关联的Window对象,用来描述一个应用程序窗口.每一个应用程序窗口内部又包含有一个View对象,用来描述应用程序窗口的视图.应用程序窗口视图是真正用来 ...
- 写给java程序员的c++与java实现的一些重要细微差别
0.其实常规的逻辑判断结构.工具类.文件读写.控制台读写这些的关系都不大,熟悉之后,这些都是灵活运用的问题. 学习c/c++需要预先知道的一个前提就是,虽然有ANSI C标准,但是每个c/c++编译器 ...
- 集成自动化的条形码功能到internet应用程序，网站或自定义Java应用程序的条码控件Java Barcode Package
Java Barcode Package控件是一款条码生成控件,包含所有的JavaBean,Applets,Servlets和类库可以使用于装有Java虚拟机的任何平台,包括Windows®, Lin ...
随机推荐
- 复习MintUI
一.表单----复选框列表 1.<mt-checklist title="标题" options="['a','b','c']" #选项列表 v-mode ...
- 给DataTable添加行的几种方式
最近做项目的时候遇到向已有Table中添加另外一个Table中的某一行数据.我是采用这样思路做的: DataTable dtSource = xxxx;//获得的数据源 DataTable dtTar ...
- vue2.0 axios前后端数据处理
目前主流的 Vue 项目,都选择 axios 来完成 ajax 请求,而大型项目都会使用 Vuex 来管理数据. 前言: 使用 cnpm 安装 axios cnpm install axios -S ...
- Java流程控制以及顺序、选择、循环结构
目录 用户交互Scanner Scanner对象 hasNext()与next() hasNextLine()与nextLine() Scanner进阶用法 求和与平均数 顺序结构 选择结构 if单选 ...
- Htop/Glances/Dstat性能测试系统监控工具领域的瑞士军刀
原文链接:https://mp.weixin.qq.com/s/TvfzIy4uXHPOFQ1h5Q4KWg 建议点击原文链接查看 续上篇分享的[性能测试工具],今天整理了常用的系统监控工具,当然有特 ...
- 封装 private
封装表现: 1.方法就是一个最基本封装体. 2.类其实也是一个封装体. 从以上两点得出结论,封装的好处: 1.提高了代码的复用性. 2.隐藏了实现细节,还要对外提供可以访问的方式.便于调用者的使用.这 ...
- Kubernetes 基础资料
概述 这篇文章用来记录Kubernetes 的基础资料,整体以最新官方文档为准. 因为k8s整体比较偏运维,作为研发可先大致了解其概念及初级使用方式,后面重点学习点会放在service mesh is ...
- jupyter 文件夹重命名
jupyter 文件夹 如何重命名嘞?可能很多童鞋没找到吧,哈哈哈 我们先创建一个文件夹,如何创建嘞,往下看. 然后我们就可以看到, 如何重命名呐,注意注意了啊,选中你创建的文件夹,单击Rename. ...
- html5学习之路_007
CSS概述 CSS指层叠样式表 CSS样式表极大地提高了工作效率 CSS基础语法 selector { property:value } 例:hi {color:red; font-size:14px ...
- [书籍分享]0-006.App营销解密：移动互联网时代的营销革命
封面 内容简介 如何在移动互联网上推广和销售自己的产品?如何通过移动互联网为顾客提供服务?如何在移动互联网上树立和传播自己的品牌?这几乎是当下所有互联网企业和传统企业都在思考的问题,企业要想在移动互联 ...