**小白的Java学习之旅**------数组

1.什么是数组？
概念：数组是内存中一块连续的内存空间，用于存放多个相同类型的数据。
2.定义一个数组
1.数组的声明：定义了数组将要存放的数据类型
          语法：数据类型[] 数组名；
          eg:int[] a;//建议
          int []a;
          int a[];//c语言写法
为数组分配空间：在内存中开辟一块空间用于存放数据
语法：数组名 = new int[数组的长度] ；
eg: a = new int[5];

关于数组定义的方式
1)声明 分配空间
第一种：先声明 后分配空间
    eg:int[] a ; a = new int[5];
第二种：声明的同时并分配空间
    eg：

int[] a = new int[5];
for(int i = 0;i<a.length;i++){
	System.out.println(a[i]);
}

2)先声明 同时为数组元素赋值
    第一种：先声明后赋值：
    int[] a ;a = new int[]{元素1，元素2…};
    第二种：声明的同时赋值：
    int[] a = new int[]{元素1，元素2…};
    可以简写为int[] a = {元素1，元素2…};
注意下面的错误写法：
    int[] a ;
    a = {元素1，元素2…};
案例：

public class V{
	public static void main(String[] args){
		int[] a = {1,4,6,7,8};
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]);
		} 
	}
}

3.使用数组
1.数组的下标：0~数组长度-1
2.数组的长度：
    语法：数组名.length;
int[] a;
a = new int[5];
a.length == 5;
存数据： 数组名[下标] = 数值；
eg:a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
取数据：
数组的遍历：用循环将数组中的元素打印出来：

for(int i = 0;i<a.length;i++){
			System.out.println(a[i]);
		} 

异常访问情况：
当访问数组元素是，下标超出了数组的length-1 就会报数组下标越界异常

4.数组元素的默认值
当数组定以后，数组每个下标的元素都会有一个默认值，默认值和数组的类型有关
1.整型（byte，short，int,long） 默认值为：0；
2.浮点型（float,double） 默认值为：0.0；
3.字符型（char）默认值为：’\u0000’；
4.布尔类型（boolean）默认值为：false
引用数据类型：
String 默认值为null

5.数组引用之间的传递
int[] a = new int[4];
int[] b = new int[5];
案例：

public class V{
	public static void main(String[] args){
		int[] a = new int[8];
		int[] c;
		c = a;
		a[0] = 98;
		a[1] = 45;
		for(int i = 0;i<c.length;i++){
			System.out.println(c[i]);
		}
	}
}

6.数组的扩容
概念：创建一个新的容量大的数组，将原数组的元素，复制到新数组中。
方法：
1）自己写
案例：

public class V{
	public static void main(String[] args){
		int[] a = {1,3,5,7};//原数组
		//创建一个新的数组 长度是原数组的2倍
		int[] b = new int[a.length*2];
		//将原数组的元素赋值到新数组中
		for(int i = 0;i<a.length;i++){
			b[i] = a[i];
		}
		//将原数组的引用指向a
		a = b;
		//遍历a数组
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+"\t");
		}
	}
}

2)System.arraycopy（原数组，原数组的起始下标，新数组，新数组的起始下标，长度）；

public class V{
	public static void main(String[] args){
		int[] a = {1,3,5,7};//原数组
		//创建一个新的数组 长度是原数组的2倍
		int[] b = new int[a.length*2];
		//将原数组的元素赋值到新数组中
		System.arraycopy(a,0,b,0,a.length);
		//将原数组的引用指向a
		a = b;
		//遍历a数组
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+"\t");
		}
	}
}

3)利用java.util包下的Arrays.copyof（原数组，新数组的长度），返回值的一个新的数组
案例：

public class V{
	public static void main(String[] args){
		int[] a = {1,3,5,7};//原数组
		//创建一个新的数组 长度是原数组的2倍
		int[] b = Arrays.copyOf(a,a.length*2);
		a = b;
		//遍历a数组
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+"\t");
		}
	}
}

7.数组作为函数的参数
案例：将数组遍历打印，封装在一个函数里

import java.util.*;
public class Test{
	public static void main(String[] args){
		int[] a = {2,4,5,7,8,90,45,34};
		int[] b = {7,5,3,45,78,98};
		//打印a数组
		printArray(a);
		System.out.println();
		printArray(b);
		
	}
	public static void printArray(int[] a){
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
}

8.数组作为函数的参数和返回值

import java.util.*;
public class Test{
	public static void main(String[] args){
		int[] n = {1,3,5,6,8};
		n = arrayCopy(n);
		printArray(n);
	}

	//形参 数组类型 返回值 数组类型
	public static int[]  arrayCopy(int[] a){
		int[] b = new int[a.length*2];
		//将原数组的元素复制到新的数组
		for(int i = 0;i<a.length;i++){
			b[i] = a[i];
		}
		return b;
	}
	//遍历打印
	public static void printArray(int[] a){
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
}

9.函数可变长参数

案例：计算2个数的和 3个数的和
语法：
public static 返回值类型 函数名（数据类型…）{ }
eg:public static 返回值类型 函数名（int …参数名）{ }
案例：

import java.util.*;
public class Test{
	public static void main(String[] args){
		printArgs(1);
		printArgs(2,3);
		printArgs(3,5,7,9,90);
	}
	// 							int[] b
	public static void printArgs(int...b){
		for(int i = 0;i<b.length;i++){
			System.out.print(b[i]+" ");
		}
		System.out.println();
	}
}

注意：
1.一个可变长度的参数不能同时定义两个或多个

(int...a,int...b)//error

2.一个函数里可变长度参数只能有一个切必须在参数列表的最后

(int...a,int b)//error

(int a,int b,int...c)//right

10.数组的排序
数组的排序：将多个数据按照从小到大或者从打到小的顺序进行排列
1.冒泡排序
规则：相邻两个元素进行比较，若前者大于后者则两者交换位置，第一轮会得出最大的元素，一共进行（数组长度-1）轮比较
代码：

import java.util.*;
public class Test{
	public static void main(String[] args){
		int[] a ={45,89,4,12,65,9,32};
		for(int i = 1;i<a.length;i++){
			for(int j = 0;j<a.length-i;j++){
				if(a[j] >a[j+1]){
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
		//打印排好序的数组
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
}

2.选择排序
规则：数组中的每个元素，分别和其后的元素进行对比，如果此元素大于后者那么两者交换位置

import java.util.*;
public class Test{
	public static void main(String[] args){
		int[] a ={45,89,4,12,65,9,32};
		for(int i = 0;i<a.length;i++){
			for(int j = i+1;j<a.length;j++){
				if(a[i] >a[j]){
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
		//打印排好序的数组
		for(int i = 0;i<a.length;i++){
			System.out.print(a[i]+" ");
		}
	}
}

3.快速排序
调用函数Arrays.sort（要排序的数组）；

11.二维数组
1.概念：在二维数组中的每一个元素都是一个一维数组
2.定义一个二维数组
语法：
数据类型[ ][ ] 数组名；
数组名 = new 数据类型[数组长度][数组长度]

二维数组定义方式：
1.声明 开辟空间
        1)声明 在开辟空间
        int[][] a;a = new int[3][4];
        2）声明并开辟空间
        int[][] a = new int[3][4];

2.声明 为元素赋值
        1）声明 再赋值
        int[][] a; a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        2）声明并赋值
        int[][] a = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        简写：int[][] a = {{1,2,3},{4,5,6},{7,8,9}};
        注意：简写声明和赋值必须在同一句

3.为二维数组元素赋值
语法：

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

二维数组的遍历
案例：

import java.util.*;
public class Test{
	public static void main(String[] args){
		//定义一个二维数组
		int[][] a = new int[3][4];
		a[0][0] = 1;
		a[0][1] = 2;
		a[0][2] = 3;
		a[0][3] = 4;
		a[1][0] = 3;
		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();
		}	
	}
}

4.不规则的二维数组
形式：int[][] a = {{1,2},{4,5,6},{7,8,9,4}};
案例：

import java.util.*;
public class Test{
	public static void main(String[] args){
		//定义一个二维数组
		int[][] a = new int[3][];
		//a = {new int[4],new int[5],a[2] = int[9]}
		a[0] = new int[4];
		a[1] = new int[5];
		a[2] = new int[9];
		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();
		}	
	}
}

注意：

int[][] a = new int[][3];//error

在定义二维数组时，必须先定义高维数组

int[][] a = new int[高维][低维]