java中将一个字符数组赋值给另一个，两者的变化怎么是同步的？怎么才能让他们独立开？
比如有一个int[][] a 已经存在值，现在定义int[][] b=a;之后改变a的值，为何b也跟着改变？怎么才能那个让b不跟随a改变？如果b非变不可，我想记录下a没改变之前的值该怎么办？谢谢



 

如果需要b不变，就必须用for循环，使a数组的每个元素都复制到b的数组里。之所以b会随着a变化，那是因为他们指向了同一个对象。

比如有一个int[][] a 已经存在值，现在定义int[][] b=a;之后改变a的值，为何b也跟着改变？怎么才能那个让b不跟随a改变？如果b非变不可，我想记录下a没改变之前的值该怎么办？

如果需要b不变，就必须用for循环，使a数组的每个元素都复制到b的数组里。之所以b会随着a变化，那是因为他们指向了同一个对象。

List例子： 

ArrayList a, 仅仅只是声明了一个list变量，其未来作用相当于C++中的引用变量，亦或者相当于一个对象块的索引，但并未为其分配具体的完整的对象所需要的内存空间，其所分配的空间仅仅只是”a”变量所需空间；

实例化：实例化的过程是为对象分配完整的所需内存空间。此时，对象a才是该list的一个实例，然后将分配的内存地址返回给定义的变量“a”;



ArrayList<String> A= new ArrayList<String>();  
A.add("1");  
A.add("2");  
ArrayList<String> B;  
B = A; 

此时B对象相当与A对象的引用，而并不是将A对象的值单纯的传递给B对象。即：B对象的操作将直接改变A对象。如B.add(“3”);结果A中也包含了“3”；

以下的方法也是相同的道理：

    ArrayList B　＝ new ArrayList<String>();  
    B.addAll(A);  



所以我们想要两个集合相同，又不指向一个地址，就需要for循环来遍历重新指向新的地址。

一、问题描述

将一个数组（或请求返回的json结果为数组），如

 

a  = [0，1，2，3，4]


赋值给另一个空的数组

 

b = []


会出现如果修改a或b中的数据，a和b都会发生改变，那么该怎么解决呢？

二、错误原因

数组是一种引用数据类型，数组引用变量只是一个引用，数组元素和数组变量在内存里是分开存放的

实际的数组元素被存储在堆（heap）内存中；数组引用变量是一个引用类型的变量，被存储在栈（stack）内存中。

基本类型：基本的数据类型有：undefined，boolean，number，string，null。 基本类型存放在栈区，访问是按值访问的，就是说你可以操作保存在变量中的实际的值。
	
引用类型：引用类型指的是对象。可以拥有属性和方法，并且我们可以修改其属性和方法。引用对象存放的方式是：在栈中存放对象变量标示名称和该对象在堆中的存放地址，在堆中存放数据。
对象使用的是引用赋值。当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在堆中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容，因此，两个对象是联动的。

三、解决办法

3.1、push()

 

for(let i = 0; i< a.length ; i++){
  b.push(a[i])
}


貌似并不是很好用

3.2、concat()

 

let b = [].concat(a)


貌似也不是很好用

3.3、JSON.parse & JSON.stringify

 

let b = JSON.parse(JSON.stringify(a))


好用！就是他了！

原理：实现对象的深拷贝（利用JSON.stringify 将js对象序列化（JSON字符串），再使用JSON.parse来反序列化(还原)js对象）

戳：JSON.parse()和JSON.stringify()用法解析

2018.12.09更新

深拷贝存在的坑


原文链接：关于JSON.parse(JSON.stringify(obj))实现深拷贝应该注意的坑

荐读：javaScript中浅拷贝和深拷贝的实现


如果obj里面有时间对象，则JSON.stringify后再JSON.parse的结果，时间将只是字符串的形式。而不是时间对象；
	
如果obj里有RegExp、Error对象，则序列化的结果将只得到空对象；
	
如果obj里有函数，undefined，则序列化的结果会把函数或 undefined丢失；
	
如果obj里有NaN、Infinity和-Infinity，则序列化的结果会变成null；
	
JSON.stringify()只能序列化对象的可枚举的自有属性，例如 如果obj中的对象是有构造函数生成的， 则使用JSON.parse(JSON.stringify(obj))深拷贝后，会丢弃对象的constructor；
	
如果对象中存在循环引用的情况也无法正确实现深拷贝；

	可以通过封装方法来解决以上的坑，代码如下：
 

function  deepClone(data) {
      const type = this.judgeType(data);
      let obj;
      if (type === 'array') {
        obj = [];
      } else if (type === 'object') {
        obj = {};
      } else {
    // 不再具有下一层次
        return data;
      }
      if (type === 'array') {
        // eslint-disable-next-line
        for (let i = 0, len = data.length; i < len; i++) {
          obj.push(this.deepClone(data[i]));
        }
      } else if (type === 'object') {
        // 对原型上的方法也拷贝了....
        // eslint-disable-next-line
        for (const key in data) {
          obj[key] = this.deepClone(data[key]);
        }
      }
      return obj;
    },


function  judgeType(obj) {
  // tostring会返回对应不同的标签的构造函数
      const toString = Object.prototype.toString;
      const map = {
        '[object Boolean]': 'boolean',
        '[object Number]': 'number',
        '[object String]': 'string',
        '[object Function]': 'function',
        '[object Array]': 'array',
        '[object Date]': 'date',
        '[object RegExp]': 'regExp',
        '[object Undefined]': 'undefined',
        '[object Null]': 'null',
        '[object Object]': 'object',
      };
      if (obj instanceof Element) {
        return 'element';
      }
      return map[toString.call(obj)];
    },


2019.01.10更新

使用第三方的库进行深拷贝：lodash

该函数库也有提供_.cloneDeep用来做 Deep Copy

 

var _ = require('lodash');
var obj1 = {
    a: 1,
    b: { f: { g: 1 } },
    c: [1, 2, 3]
};
var obj2 = _.cloneDeep(obj1);
console.log(obj1.b.f === obj2.b.f);
// false

更多内容查看：https://www.cswritehelp.com

在学习c++的过程中，我们经常使用到数组，那怎么去定义一个类去实现数组的功能呢？

我们先列出一些经常对数组进行的一些操作，

1、	创建一个指定容量的数组

2、	用已有的数组初始化另一个数组

3、	用已有的数组给另一个数组赋值

4、	给数组添加元素/给数组元素赋值

5、	获取数组指定元素的值

6、	输入一定数量的值，将值赋给数组

7、	输出数组

……

还有很多，本次只实现以上功能

以下是代码：
1、MyArray.h 文件 ：MyArray 类的声明
#pragma once
#include <iostream>
using namespace std;
class MyArray
{
public:
	// 构造函数
	MyArray();
	// 拷贝构造函数
	MyArray(const MyArray&m);
	// 有参构造函数
	MyArray(int len);
	// 析构函数
	~MyArray();
	// 设置值
	void setData(int index, int data);
	// 获取值
	int getData(int index);
	// 获取长度
	int getLen()const;
	// 重载赋值运算符
	MyArray & operator =(const MyArray&);
	// 重载 []
	int & operator [](int i)const;
	// 重载<<
	friend ostream & operator << (ostream & os, const MyArray & ma);
	// 重载>>
	friend istream & operator >> (istream & is, MyArray & ma);
private:
	int len; // 数组长度
	int * space;// 指针 指向堆上的空间
};

2、MyArray.cpp 文件 ：MyArray 类的实现
#include "MyArray.h"
// 构造函数
MyArray::MyArray()
{ 
 	this->len = 0; this->space = NULL; 
}
// 拷贝构造函数
MyArray::MyArray(const MyArray&m)
{
	this->len = m.len;
	// 深拷贝
	if (this->space == NULL)
	{
		this->space = new int[this->len];//申请分配新内存
	}
	for (int i = 0; i < this->len; i++)
	{
		this->space[i] = m.space[i];//拷贝值
	}
}
//有参构造函数
MyArray::MyArray(int len)
{
	if (len <= 0) 
	{
	 	this->len = 0; 
	 	return; 
	}
	else
	{
		this->len = len;
		this->space = new int[this->len];
	}
}
// 析构函数
MyArray::~MyArray()
{
	if ((this->space) != NULL)
	{
		delete this->space;
		this->space = NULL;
		len = 0;
	}
}
// 设置值
void MyArray::setData(int index, int data) 
{ 
	if (this->space != NULL) 
	{ 
		this->space[index] = data; 
	}
}
// 获取值
int MyArray::getData(int index) 
{ 
	return this->space[index]; 
};
// 获取长度
int MyArray::getLen()const
{
 	return this->len;
};
// 重载赋值运算符
MyArray&  MyArray::operator =(const MyArray&m)
{
	if (this == &m) 
	{ 
		return *this; 
	}
	
	// 如果数组不为空，清空数组当前内容
	if (this->space != NULL)
	{
		delete[] this->space;
		this->space = NULL;
	}
	// 深拷贝
	this->len = m.len;
	this->space = new int[this->len];
	for (int i = 0; i < this->len; i++)
	{
		this->space[i] = m.space[i];
	}
	return *this;
}
// 重载 []
int & MyArray::operator [](int i)const
{ 
 	return this->space[i]; 
}
// 重载 <<
ostream & operator << (ostream & os, const MyArray & ma)
{
	for (int i = 0; i < ma.getLen(); i++)
	{ 
		os << ma[i] << " "; 
	}
	return os;
}
// 重载 >>
istream & operator >> (istream & is, MyArray & ma)
{
	cout << "请输入 " << ma.getLen() << " 个数" << endl;
	for (int i = 0; i < ma.getLen(); i++)
	{ 
		is >> ma[i]; 
	}
	return is;
}

3、main 方法调用
#include <iostream>
#include "MyArray.h"
using namespace std;
void main() 
{
	MyArray arr1;		// 声明数组
	MyArray arr2(10);	// 声明一个容量为10的数组
	cin >> arr2;		// 用输入值为数组赋值
	cout << "arr2 : " << arr2 << endl;	// 输出数组
	
	MyArray arr3 = arr2;// 用已有的数组初始化另一个数组
	cout << "arr3 : " << arr3 << endl;	// 输出数组

	arr1 = arr2;		// 用已有的数组给另一个数组赋值
	cout <<"arr1 : "<< arr1 << endl;	// 输出数组

	MyArray arr4(5);	// 给数组添加元素/给数组元素赋值
	for (int i = 0; i < 5; i++) { arr4[i] = i + 10; }
	cout << "arr4 : " << arr4 << endl;	// 输出数组

	// 获取数组指定元素的值
	cout << "arr4 [4] = " << arr4[4] << endl;
}

4、运行结果

以上。

感谢您的浏览