数组-一维数组

数组

概念：

​ 所谓数组就是相同类型的的元素按一定的顺序的集合。在Java语言中，数组的元素可以由简单数据类型的量组成，也可以由对象组成。数组中的每个元素都具有相同的的数据类型，可以用数组的数组名和下标来唯一确定数组元素的个数，Java数组的长度。
​ 根据数组存放元素的组织结构，可以将数组分为一维数组、二维数组以及多维数组。在这里讲解一下一维数组及二维数组。
​ 在Java语言中，数组中数据的获取，通过元素的下标来获取，下标是从0开始的。（如果需要构造一个储存不同类型的的数据，或者长度可以动态更改的结构，可以考虑向量Vector类型）

1、创建数组

​ 一维数组是一组相关变量的一维集合，其逻辑结构就是线性表。使用数组需要经过定义，初始化和应用等过程。
​ 使用Java语言中的Java数组，一般经过3个步骤：声明数组类型，分配内存空间，数组元素赋值。

1.1语法：

数组类型 数组名【】；//声明数组类型
​ 数组名 = new 数据类型【数组长度】；//分配内存空间，
​ 或者 ：数组类型 数组名 = new 数组类型【数组长度】；
​ 【】是一维数组的标识，可以放置在数组名前面或者后面。
​ 初始化数组在Java语言中分为两种方式，分为静态初始化与 动态初始化。这两种方式可以将数组中的元素初始化为指定值，而非默认值。

1.1.1动态初始化

​ 动态初始化就是将数组的定义和数组的初始化（赋值）分开来进行。

int a[] = new int[10];
int[] a = new int[10];
char[] c = new char[10]；
    c[0]='h';
    c[1]='e';
    c[2]='l';
    c[3]='l';
    c[4]='o';
    c[5]=',';
    c[6]='w';
    c[7]='o';
    c[8]='r';
    c[9]='d';

1.1.2静态初始化

​ 静态初始化就是在定义数组的时候就对数组进行初始化（赋值）。其中不要在数组声明中指定数组的大小，否则会发生错误。

int b[] = new int[]{1,2,3,4,5,6,7,8,9,0};
int c[] = {1,2,3,4,5,6,7,8,9,0};
char[] a = new char[] {'h','e','l','l','o',',','w','o','r','d'};

2、数组的长度与遍历。

2.1长度

对于每个数组都有一个属性length指明它的长度，如a.length指出数组a所含元素的个数。数组一旦创建后，长度不可改变。同时，在Java语言中，允许0长度的数组存在。另外，Java语言与C，C++不同，Java对数组的元素要进行越界以保证安全性。
​ 定义了数组以后，要想使用数组里的元素，可以利用数组名和下标来实现，数组元素的引用方式为：**数组名【下标】；**下标为0代表第一个元素，length-1表示第length个数。

2.2遍历

​ 数组的遍历就是获取数组中的 每个元素，通常遍历数组都是使用for循环来实现数组的遍历。

一维数组：

​ 一维数组的很简单，就是利用单层的for循环，int i=0从下标为0开始循环，a.length-1 指下标的最大值，也就是数组的长度，i++依次递增打印每一个元素。

//三个列子：	
public static void main(String[] args) {
		fuzhi();//调用静态方法显示数组，并实现遍历
		System.out.println("<----------- 分割线 ----------->");
		zhifu();
		System.out.println("<----------- 分割线 ----------->");
		day();
	}
	//数组动态初始化（赋值）并且打印
	public static void fuzhi() {
		int[] a= new int[50];
		for (int i = 0; i < a.length; i++) {
			a[i] = new Random().nextInt(50);	//初始化（赋值）
		}
        for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+",");		//实现遍历数组
		}
        
	}
	//数组字符串静态初始化（字符串赋值）打印
	public static void zhifu() {
		String a[] = new String[] {"大爷","二爷","三爷","四爷","六爷","七爷","八爷"};
		for (int i = 0; i < a.length-1; i++) {
			System.out.print(a[i]+",");//遍历数组
		}
	}
	//数组静态输出并实现动态拼接
	public static void day() {
		int[] a = new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
		for (int i = 0; i < a.length; i++) {
			System.out.println(i+1+"月有"+a[i]+"天！");//遍历数组
		}
	}

二维数组：

​ 二维数组的遍历与以为数组的差不多，但是需要双层的for循环来实现，同样的通过数组的length属性获取数组的长度，然后将二维数组的元素呈梯形输出。在这里需要注意，外层使用a.length来结束循环，而内层使用a[i].length来结束循环。：

	public static void main(String[] args) {
		//定义二维数组并赋值
		int[][] a = new int[][]{{1,2},{2,3},{2,5,6},{5,7},{2,4}};
		//遍历二维数组
		for (int i = 0; i < a.length; i++) {
			//遍历里面数组的元素
			for (int j = 0; j < a[i].length; j++) {
				System.out.print(a[i][j]+",");
			}
			System.out.println();
		}	
	}
<---------------- 结果显示------------>
1,2,
2,3,
2,5,6,
5,7,
2,4,

3、数组工具

3.1 Arrays.toString(数组)

把数组里的数据，用逗号连接成一个字符串。

public static void main(String[] args) {
		int [] a= shuzu();
		gongju(a);	
	}
	//定义数组
	public static int[] shuzu() {
		int[] a = new int[10];
		for (int i = 0; i < a.length - 1; i++) {
			a[i] = new Random().nextInt(50);
		}
		return a;
	}
	//测试数组工具：
	public static void gongju(int[] array) {
		String x = Arrays.toString(array);
		System.out.println(x);
	}
<--------------- 结果 ---------------->
[3, 39, 18, 33, 1, 35, 14, 42, 47, 0]

3.2Arrays.sort(数组)

对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。

	public static void main(String[] args) {
		int [] a= shuzu();
		gongju(a);	
	}
	//定义数组
	public static int[] shuzu() {
		int[] a = new int[10];
		for (int i = 0; i < a.length - 1; i++) {
			a[i] = new Random().nextInt(50);
		}
		return a;
	}
	
	//测试数组工具：
	public static void gongju(int[] array) {
		Arrays.sort(array);				//使用sort方法排序，按从小到大的顺序排列
		String x = Arrays.toString(array);//把数组里面的数据，用逗号连接成一个字符串
		System.out.println(x);
	}
<--------------- 结果 ---------------->
    [0, 8, 11, 12, 17, 26, 30, 33, 37, 45]

3.3数组的复制

​ 在Java语言中，通常会用到数组的复制，简单来说就是指将原数组的元素作为副本，赋值到新的、目标数组对于位置，有三种方法：
​ 使用循环语句赋值；
​ 使用clone（）方法；
​ 使用Array.copyof(新数组名，新容量)

######3.3.1 使用循环语句赋值；

​ 使用循环语句访问数组，对其中每一个元素进行访问操作：

public static void main(String[] args) {
		int[] a = new int[] {1,2,3,4,5,6,7,8,9};
		int[] b = new int[a.length];
		//遍历a数组给b赋值
		for (int i = 0; i < a.length; i++) {
			b[i] = a[i];
		}
		//遍历输入b数组的结果
		for (int i = 0; i < b.length; i++) {
			System.out.print(b[i]+",");
		}
	}
<--------------- 结果 ---------------->
    1,2,3,4,5,6,7,8,9,

3.3.2使用clone（）方法；

​ 在Java中，object类的所有类的父类，使用clone()方法一般用于创建并返回此对象的一个副本，由此可以复制数组：

public static void main(String[] args) {
		int[] a = new int[] {1,2,3,4,5,6,7,8,9};
		//复制数组元素
		int[] b = a.clone();			
		//遍历输入b数组的结果
		for (int i = 0; i < b.length; i++) {
			System.out.print(b[i]+",");
		}
	}
<--------------- 结果 ---------------->
    1,2,3,4,5,6,7,8,9,

3.3.3Arrays.copyOf(数组，新的长度（容量）)

​ 把数组复制成一个指定长度的新数组。
​ 新数组长度（容量）大于原数组，复制数组原有的元素，并增加位置。–数组的扩容
​ 新数组长度（容量）小于原数组，相当于截取前一部分数据。–数组的缩容

public static void main(String[] args) {
		int [] a= shuzu();
		gongju(a);	
		System.out.println("<-------- 数组复制 ---------->");
		copy(a);
	}
	//定义数组
	public static int[] shuzu() {
		int[] a = new int[10];
		for (int i = 0; i < a.length - 1; i++) {
			a[i] = new Random().nextInt(50);
		}
		return a;
	}
	//测试数组工具：
	public static void gongju(int[] array) {
		Arrays.sort(array);				//使用sort方法排序
		String x = Arrays.toString(array);//把数组里面的数据，用逗号连接成一个字符串
		System.out.println(x);
	}
	//新建方法，演示数组的复制工具
	public static void copy(int[] a) {
		int[] b = Arrays.copyOf(a, 20);//****这里是复制的重点**
		System.out.println("新数组的长度为："+b.length);
		System.out.println("新数组的元素为"+Arrays.toString(b));
	}
<--------------- 结果 ---------------->
    [0, 4, 6, 11, 13, 25, 28, 41, 46, 46]
<-------- 数组复制 ---------->
新数组的长度为：20
新数组的元素为[0, 4, 6, 11, 13, 25, 28, 41, 46, 46, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]