JS合并两个数组的方法

我们在项目过程中，有时候会遇到需要将两个数组合并成为一个的情况。比如：

    var a = [1,2,3];
    var b = [4,5,6];

有两个数组a、b，需求是将两个数组合并成一个。方法如下：

• 1、concat
  js的Array对象提供了一个叫concat()方法，连接两个或更多的数组，并返回结果。

   var c = a.concat(b);//c=[1,2,3,4,5,6];

这里有一个问题，concat方法连接a、b两个数组后，a、b两个数组的数据不变，同时会返回一个新的数组。这样当我们需要进行多次的数组合并时，会造成很大的内存浪费，所以这个方法肯定不是最好的。

• 2、for循环

  大概的思路是：遍历其中一个数组，把该数组中的所有元素依次添加到另外一个数组中。直接上代码：

  for(var i in b){
    a.push(b[i]);
  }

   

  这样的写法可以解决第一种方案中对内存的浪费，但是会有另一个问题：丑！这么说不是没有道理，如果能只用一行代码就搞定，岂不快哉~

• 3、apply
  函数的apply方法有一个特性，那就是func.apply(obj,argv)，argv是一个数组。所以我们可以利用这点，直接上代码：

   a.push.apply(a,b);

调用a.push这个函数实例的apply方法，同时把，b当作参数传入，这样a.push这个方法就会遍历b数组的所有元素，达到合并的效果。

这里可能有点绕，我们可以把b看成[4,5,6]，变成这样：

 a.push.apply(a,[4,5,6]);

然后上面的操作就等同于：

a.push(4,5,6);

这样就很清楚了！

　　另外，还要注意两个小问题：

　　1）以上3种合并方法并没有考虑过a、b两个数组谁的长度更小。

　　所以好的做法是预先判断a、b两个数组哪个更大，然后使用大数组合并小数组，这样就减少了数组元素操作的次数！

　　2）有时候我们不希望原数组（a、b）改变，这时就只能使用concat了。

转自：http://www.cnblogs.com/Being-a-runner-up/p/5627166.html

js合并数组的三种方法

前提：两个数组a=[1,2,3,4]、b=[5,6,7]，将其合并为一个数组

1. concat

//js的Array对象提供了一个叫concat()方法，连接两个或更多的数组，并返回结果。
var c = a.concat(b); //c=[1,2,3,4,5,6,7];
//concat方法连接a、b两个数组后，a、b两个数组的数据不变，同时会返回一个新的数组。
//需要进行多次的数组合并时，会造成很大的内存浪费，如果是数据量比较小的时候，还可以勉强用

2. for循环

//遍历其中一个数组，把该数组中的所有元素依次添加到另外一个数组中。
for( var i in b)
{
  a.push(b[i]);
}
//这样写可以解决对内存的浪费，但是会有另一个问题：不太好看！

3. apply

//函数的apply方法有一个特性，那就是func.apply(obj,argv)，argv是一个数组。
a.push.apply(a,b);
//调用a.push这个函数实例的apply方法，同时把，b当作参数传入，这样a.push这个方法就会遍历b数组的所有元素，达到合并的效果。
a.push.apply(a,[5,6,7]);《==》a.push.(5,6,7);

注意：
1）以上3种合并方法并没有考虑过a、b两个数组谁的长度更小。所以好的做法是预先判断a、b两个数组哪个更大，然后使用大数组合并小数组，这样就减少了数组元素操作的次数！
2）有时候我们不希望原数组（a、b）改变，这时就只能使用concat了。

Java基础——数组

Java基础知识

数组

1.数组简介

数组是用来存储相同数据类型的一组数据

• 声明一个变量就是在内存中划出一块空间
• 声明一个数组就是在内存中划出一串连续的空间

数组的四要素：

• 数组名称：用来区分不同的数组
• 数组元素：向数组中存放的数据
• 元素类型：数组元素的数据类型
• 元素下标：数组元素的编号，也称为索引，从0开始，通过下标来访问数组元素

2.基本用法

步骤：
1. 声明数组
指定元素的类型
数据类型[] 数组名称; 或 数据类型 数组名称[];
2. 分配空间
指定数组长度/大小，即分配几个连续的空间
数组名称=new 数组类型[大小];
4. 数组赋值
向数组中添加元素
数组名称[下标]=值;
4. 访问元素
获取数组中的元素
数组名称[下标];

public static void main(String[] args) {
		int[] nums;
		// 2.分配空间，指定数组大小
		nums = new int[4];

		// 3.数组赋值
		nums[0] = 10;
		nums[1] = 20;
		nums[2] = 30;
		nums[3] = 40;

		// 4.访问元素
		System.out.println("第三个元素：" + nums[2]);
		System.out.println(nums[0]);//第一个元素
		System.out.println(nums[3]); // 最后一个元素的下标为：数组长度-1

		System.out.println(nums); // 直接访问数组名称时会显示数组在内存中的首地址

	}

运行结果：

第三个元素：30
10
40
[I@279f2327

3.数组元素的默认值

4.合并两个数组

 public static void main(String[] args) {
	  //合并两个数组
	  int Array1[]= {10,20,30,40};
	  int Array2[]= {50,60,70};
	  //合并数组的长度等于两个数组的长度
	  int Array [] = new int[Array1.length+Array2.length];
	  //循环赋值
	  for(int i =0;i<Array.length;i++){
		  if(i<Array1.length) {
			  Array[i]=Array1[i];
			  
		  }else {
			  Array[i]=Array2[i-Array1.length];
		  }

	  }
	  System.out.println(Arrays.toString(Array));
  }

运行结果：

[10, 20, 30, 40, 50, 60, 70]

5.多维数组

二维数组可以认为是特殊的一维数组，一维数组中的每个元素又是一个一维数组
分类：

• 规则的二维数组
• 不规则的二维数组
  a、规则二维数组

		// 定义二维数组
		//动态初始化
		int[][] nums;

		// 分配空间
		nums = new int[3][2]; // 3表示第一维的长度，2表示第二维的长度（可以认为是3行2列，规则的）

		// 赋值
		nums[0][0] = 10;
		nums[0][1] = 20;
		nums[1][0] =30;
		nums[1][1] = 40;
		nums[2][0] = 50;
		nums[2][1] = 60;

		/*
		 * 定义数组的同时为其赋值
		 * 静态初始化
	   */

		int[][] a = { { 13, 4 }, { 6, 65 }, { 8, 14 } };

b、不规则数组

        //动态
		int[][] c = new int[4][]; // 只指定第一维的长度
		c[0] = new int[3]; // 第二维的长度有所不同
		c[1] = new int[1];
		c[2] = new int[2];
		c[3] = new int[3];
		c[0][0] = 5;
		c[0][1] = 23;
		c[0][2] = 9;
		c[1][0] = 76;
		c[2][0] = 6;
		c[2][1] = 3;
		c[3][0] = 79;
		c[3][1] = 7;
		c[3][2] = 90;
		//静态
		int[][] d = { { 5, 23, 9 }, { 76 }, { 6, 3 }, { 79, 7, 90 } };