java数组a复制到数组b-java可变数组复制

1.新增/删除 1.Array.unshift(newEle, newEle2, newEle3, ...)（改变原数组）

将一个或多个元素添加到数组的开头并返回新的长度

队列方法

栈数据结构的访问规则是LIFO（Last-In-First-Out，后进先出），而队列数据结构的访问规则是FIFO（First-In-First-Out，先进先出）进先出）

let a = [1,2,3,4,5];   
let b = a.unshift(-2,-1); 
//a:[-2,-1,1,2,3,4,5] 
//b:7  

2. Array.push(newEle , newEle2 , newEle3 , ...) （改变原数组）

向数组末尾添加一个或多个元素并返回新的长度

堆叠法

堆栈是一种LIFO（Last-In-First-Out，后进先出）数据结构

let a = [1,2,3,4,5];   
let b = a.push(6 , 7); 
//a:[-2,-1,1,2,3,4,5,6,7] 

3. Array.shift()（改变原数组）

删除原数组的第一项，返回删除元素的值； 如果数组为空，则返回 undefined

队列方法

栈数据结构的访问规则是LIFO（Last-In-First-Out，后进先出），而队列数据结构的访问规则是FIFO（First-In-First-Out，先进先出）进先出）

let a = [1,2,3,4,5];   
let b = a.shift(); 
//a:[2,3,4,5] 
//b:1

4. Array.pop()（改变原数组）

删除原数组的最后一项，返回删除元素的值； 如果数组为空，则返回 undefined

堆叠法

堆栈是一种LIFO（Last-In-First-Out，后进先出）数据结构

let a = [1,2,3,4,5];   
let b = a.pop(); 
//a:[1,2,3,4] 
//b:5

5. Array.concat(arr, arr2, arr3, ...)（不改变原数组）

连接值或其他数组

let a = [1,2,3,4,5];   
let b = a.concat(6,7); 
//a:[1,2,3,4,5] 
//b:[1,2,3,4,5,6,7] 

6. Array.slice(start,end)（不改变原数组）

返回从现有数组中选择的元素开始包含，结束不包含

类似于strings的str.slice(start, end)方法，就是用数组替换字符串

let a = [1,2,3,4,5];   
let b = a.slice(2,5); 
//a:[1,2,3,4,5] 
//b:[3,4,5] 

我们也可以不带参数调用它：arr.slice() 将创建 arr 的副本。 它通常用于获取副本以进行不影响原始数组的进一步转换。

7. Array.splice(index,num,newEle ,newEle 2,newEle 3,...)（改变原数组）

（我是一个亲爱的，我很自豪）

在数组中添加/删除项目，然后返回删除的项目

索引是必需的。 指定添加/删除项目的整数，使用负数指定从数组末尾开始的位置。

数量是必需的。 要删除的项目数。 如果设置为 0，项目将不会被删除。

newEle , newEle2 , ... 是可选的。 添加到数组的新项目。

返回包含已删除项目的新数组（如果有）。

let a = [1,2,3,4,5];
let b = a.splice(1,1);
//a: [1,3,4,5]
//b: [2]
a.splice(1,0,55);
//a:[1,55,2,3,4,5]
//b:[]

----------------------------假装分割线------------------ ----------二、遍历 1、Array.forEach（改变原数组）

它允许为数组的每个元素运行一个函数，函数的结果（如果它返回）被丢弃和忽略。

----------------------------假装分割线------------------ ----------三、转换 1、Array.map（改变原数组）

对数组的每个元素调用一个函数并返回结果数组

let arr = ["zhangsan", "lisi", "wangwu"].map(item => item.length);
console.log(arr); // 8,4,6

2. Array.sort(fn)（改变原数组）

对数组的元素进行排序，fn为排序方法函数

function sortFn(a,b){
  return a - b
}
let a = [1,3,5,4,2];
a.sort(sortFn)
//a: [1,2,3,4,5]

3. Array.reverse()（改变原数组）

对数组进行逆序排序

let a = [1,2,3,4,5];   
let b = a.reverse(); 
//a:[5,4,3,2,1] 
//b:[5,4,3,2,1]  

4. Array.join(str)（不改变原数组）

方法用于将数组中的所有元素放入一个字符串中。元素之间用指定的分隔符分隔

如果没有填写任何参数，则使用逗号作为分隔符

let a = [1,2,3,4,5];
a.join('-')
//a: [1,2,3,4,5]
//b: 1-2-3-4-5

5.减少/减少权利（fn，初始）

第一个参数fn是一个累加函数，第二个initial是初始值。 如果不填写，arr的第一个参数默认为初始值。

let arr = [1, 2, 3, 4, 5];
let result = arr.reduce((sum, current) => sum + current, 0);
console.log(result); // 15
 

----------------------------假装分割线------------------ ---------- 4.搜索1、Array.indexOf(item, from)/lastIndexOf(item, from)（不改变原数组）

返回指定字符串值在字符串中第一次出现的位置，区分大小写，没有出现则返回-1

let a = [1,2,3,4,5];
let b = a.indexOf(2);
//a: [1,2,3,4,5]
//b: 1

2.数组.includes

Array.prototype.includes 方法返回一个布尔值，指示数组是否包含给定值，类似于字符串的 includes 方法。

该方法的第二个参数表示搜索的起始位置，默认为0。 如果第二个参数为负数，则表示倒数的位置。 如果大于数组长度（比如第二个参数为-4，但数组长度为3），则重新设置为从0开始。

[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true

在这个方法之前，我们通常使用数组的indexOf方法。 indexOf 方法有两个缺点：

一是语义不够。 它的意思是找到参数值第一次出现的位置，所以比较是否不等于-1不够直观。

二是它内部使用严格相等运算符（===）进行判断，会导致对NaN的误判

3.阵列。 查找() / 查找索引()

数组实例的 find 方法用于查找满足条件的第一个数组成员。 它的参数是一个回调函数，所有数组成员依次执行回调函数，直到找到第一个返回值为true的成员，然后返回该成员。 如果没有符合条件的成员，则返回 undefined。

数组实例的findIndex方法的使用和find方法很相似，返回第一个满足条件的数组成员的位置，如果所有成员都不满足条件则返回-1。

[1, 4, -5, 10].find((n) => n < 0)
// -5

4.数组过滤器

find 方法搜索函数返回 true 的第一个（单个）元素。

如果有很多匹配项，我们可以使用 arr.filter

语法与 find 大致相同，但 filter 返回所有匹配元素的数组：

let users = [
  {id: 1, name: "John"},
  {id: 2, name: "Pete"},
  {id: 3, name: "Mary"}
];
// 返回前两个用户的数组
let someUsers = users.filter(item => item.id < 3);
alert(someUsers.length); // 2

----------------------------假装分割线------------------ ---------- 五、其他

ES6 数组的扩展

1.阵列。 从（）

Array.from 方法用于将两类对象转换为真正的数组：类数组对象和可迭代对象（包括 ES6 的新数据结构 Set 和 Map）。

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};
// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

如果参数是一个真正的数组，Array.from 将返回一个相同的新数组

2.数组.of

Array.of方法用于将一组值转换成数组

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

Array.of 总是返回一个参数值数组。 如果没有参数，则返回一个空数组。

3.数组实例的copyWithin()

数组实例的copyWithin()方法，在当前数组内java数组a复制到数组b，将指定位置的成员复制到另一个位置（原来的成员会被覆盖）java数组a复制到数组b，然后返回当前数组。 也就是说，使用这个方法会修改当前数组。

它接受三个参数。

[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]

上面代码的意思是将第3位到数组末尾的成员（4和5）复制到从第0位开始的位置，覆盖掉原来的1和2。

4.数组实例的fill()

fill 方法用给定的值填充一个数组。

fill方法还可以接受第二个和第三个参数，用于指定填充的开始和结束位置

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']

5.数组实例的entries()、keys()和values()

ES6 提供了三种新方法—— entries() 、 keys() 和 values() —— 用于遍历数组。 可以使用 for...of 循环遍历它们。 唯一的区别是keys()是键名的遍历，values()是键值的遍历，entries()是键值对的遍历。

如果不使用for...of循环，可以手动调用遍历器对象的next方法进行遍历

5.数组实例的flat()和flatMap()

数组的成员有时是数组，Array.prototype.flat() 用于将嵌套数组“扁平化”为一维数组。 此方法返回一个新数组，对原始数据没有影响。

[1, 2, [3, 4]].flat()
// [1, 2, 3, 4]

flat() 默认只会“压平”一层。 如果要“展平”多层嵌套数组，可以将flat()方法的参数写成整数，表示要展平的层数。 默认值为 1。

[1, 2, [3, [4, 5]]].flat()
// [1, 2, 3, [4, 5]]

[1, 2, [3, [4, 5]]].flat(2)
// [1, 2, 3, 4, 5]

如果不管嵌套多少层都想转换成一维数组，可以使用Infinity关键字作为参数。

[1, [2, [3]]].flat(Infinity)
// [1, 2, 3]

----------------------------假装分割线------------------ ---------- 六、数组复制 1、展开运算符【...】

传播运算符（传播）是三个点（...）。 就像rest参数的逆运算一样，将一个数组转化为以逗号分隔的参数序列。

注意只有调用函数时，展开运算符才可以放在括号中，否则会报错

const a1 = [1, 2];
const a2 = a1;
a2[0] = 2;

a1 // [2, 2]

在上面的代码中，a2 不是 a1 的克隆，而是指向相同数据的另一个指针。 修改a2会直接导致a1的改变。

const a1 = [1, 2];
// 写法一
const a2 = [...a1];
// 写法二
const [...a2] = a1;

以上两种写法中，a2是a1的克隆

2. 连接（）

连接值或其他数组

如果我们不指定参数或提供一个空数组作为参数，浅拷贝方法

const arr1 = [1, 2, 3, 4]
const arr2 = arr1.concat()
console.log('before push arr2', arr2)  //  [1, 2, 3, 4]

arr2.push(5)
console.log('after push arr1 :', arr1)  // [1, 2, 3, 4]
console.log('after push arr2 :', arr2)  // [1, 2, 3, 4, 5]

3.切片()

slice 方法根据我们指定的 start 和 end 索引从原始数组返回一个浅拷贝数组

当没有给出参数时，返回原始数组的副本

const arr1 = [1, 2, 3, 4]
const arr2 = arr1.slice(0,2)
console.log('before push arr2', arr2)  //  [1, 2, 3, 4]

arr2.push(5)
console.log('after push arr1 :', arr1)  // [1, 2, 3, 4]
console.log('after push arr2 :', arr2)  // [1, 2, 5]

4.数组.from

Array.form 方法从类数组或可迭代对象创建一个新的 Array 实例的浅表副本

console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]

手动分割线

let str = 'abc'
let strArr = Array.from(str)
console.log(strArr)   // ['a', 'b', 'c']
let arr = [1, 2, 3, 4]
let brr = Array.from(arr)
console.log(brr)      // [1, 2, 3, 4]
arr.push(5)

brr.push(10)
console.log(arr)      // [1, 2, 3, 4, 5]
console.log(brr)      // [1, 2, 3, 4, 10]

5. JSON.parse & JSON.stringify (深拷贝)

let arr = [[1], [2]]
let brr = JSON.parse(JSON.stringify(arr))
console.log(brr)    // [[1], [2]]
brr[0].push(6)
console.log(arr)    // [[1], [2]]
console.log(brr)    // [[1, 6], [2]]

这种方法适用于Oject的深拷贝，因为Array属于Oject类型，所以这里也适用

注意事项参考：

①. 如果obj中有时间对象，那么JSON.stringify后JSON.parse的结果，时间只会是字符串的形式，而不是时间对象

②. 如果obj中有RegExp和Error对象，序列化的结果只会得到空对象

③. 如果obj中有函数undefined，序列化的结果会丢失函数或undefined

④. 如果obj中存在NaN、Infinity或-Infinity，则序列化结果为null

⑤. JSON.stringify() 只能序列化对象的可枚举自身属性。 比如obj中的对象是由构造函数生成的，深拷贝后使用JSON.parse(JSON.stringify(obj))，会丢弃对象的构造函数

6.对象数组的深拷贝

      let obj = {
        name: 'zhangsan',
        age: 28,
        children: [
          { name: 'zhangsi', age: 2 }
        ]
      }
      
      function deepClone(tdata, odata) {
        for (let k in tdata) {
          // 判断数据类型
          let item = tdata[k]
          if (item instanceof Array) {
            odata[k] = []
            deepClone(item, odata[k])
          } else if (item instanceof Object) {
            odata[k] = {}
            deepClone(item, odata[k])
          } else {
            odata[k] = item
          }
        }
        return odata
      }
      let tx = deepClone(obj, {})
      console.log('deep test:', tx)