Java第四天学习（关于数组）

数组

数组：存放多个数据的集合

一维数组声明

方式：
type var[]或type[] var;
例如：

	int a[];
	int[] a1;
	double b[];
	Mydate[] c;//对象数组

一维数组初始化

• 动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行。(可以后赋值）

int[] arr=new int[3];
arr[0]=3;
arr[1]=9;
arr[2]=8;

int[] ii=new int[4];//声明一个能放4个int类型数据的数组

int[] arr=new int[]{4,2,7,1,3,5};
int[] arr0=arr; //也可以这样赋值

• 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int a[]=new int[]{3.9,8};  

int[] a={3,9,8};

int[] 110=new int[]{1,2,3,4};//声明一个存放了1.2.3.4这四个数的数组

数组元素的引用

• 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
• 数组元素的引用方式：数组名【数组元素下标】
  • 数组元素下标可以是整型常量或整型表达式。如a[3],b[i],c[6*i];
  • 数组元素下标从0开始；长度为n的数组合法下标取值范围：0–>n-1;如：int a[] =new int[3];可引用的数组元素为a[0],a[1],a[2].
• 每个数组都有一个属性length指明它的长度，例如： a.length指明数组a的长度（元素个数）
  • 数组一旦初始化，其长度不可变的。

String[] strs=new String[]{"c","a","b"};//数组内地元素都有一个引用的元素下标，这个下标是个数字，数字是从左到右从0开始
System.out.println(str[1]);//a

System.out.printn("str的数组长度是："+strs.length);//3

int[] ii=new int[2];//使用动态初始化的时候，数组的元素会有默认值，数字类型的默认值为0，对象的默认类型是null
System.out.println(ii[0]);//0

int[] ii=new int[4];
System.out.println(ii[0]); //0

ii[0]=2;//再次赋值
System.out.println(ii[0]);//2

多维数组

一维数组中的每一个元素都是一个数组，这样的数组就是二维数组

int[][] ii=new int[][]{
(1,2),(3,4)
};

二维数组[ ][ ]:数组中的数组

格式1（动态初始化）：int[ ][ ] arr=new int[3][2];
定义了一个名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有两个元素
一维数组的名称分别为arr[0],arr[1],arr[2]
给定一个一维数组1脚标位赋值位78的写法是：arr[0][1]=778;
格式2（动态初始化):int[ ][ ]arr =new int[3][ ];

int[][] ii0=new int[2][3];//第一维部分的长度是2，第二维也就是第一维的每个元素的长度是3
{
（1，23，4），
（2，4，6）
}

二维数组中有3个一维数组
每个一维数组都是默认初始化值null（注意：区别于格式1）
可以对这个三个一维数组分别进行初始化
arr[0]=new int[3];arr[1]=new int[1];arr[2]=new int[2];
注意：int[ ]arr =new int[ ][3];//非法

int[][] ii1=new int[2][];//只定义第一维的长度，第二维不定义

格式2（静态初始化）：int[ ][ ] arr=new int[ ][ ]{{3,8,2},{2,7},{9,0,1,6}
定义一个名称位arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已经初始话
第一个一维数组arr[0]={3,8,2};
第二个一维数组arr[1]={2,7};
第三个一维数组arr[1]={9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

• 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组
• java中多维数组不必都是规则矩阵形式

int[][] ii=new int[][]{
	(1,2),//第0个元素
	(4,3)//第一个元素
};
Ststem.out.println(ii[1][0]);//4

练习题
获取arr数组中所有元素的和。使用for的嵌套循环即可

j\i	j=0	j=1	j=2	j=3
i=0	2	8	2
i=1	2	7
i=2	9	0	1	6

int[][] arr=new int[][]{
	(2,8,2),
	(2,7),
	(9,0,1,6)
};
int length=arr.length;//获取数组的一维的长度
int res=0;
for(int i=0;i<length;i++){
	int arr0[]=arr[i];  //赋值
	int llen=arr0.length;//二维数组的长度
	for(int j=0;j<llen;j++){
		System.out.println(arr[j]);//282279016
		res+=arr0[j];//
	}	
}
System.out.println(res);//38

简化后：
for(int i=0;i<arr.length;i++){
	for(int j=0;j<arr[i].length;j++){
		res+=arr[i][j];
	}
}

声明：int[],x,y[],一下选项允许通过编译的是：

• x[0]=y; //false x[0]是 具体数值，y是一个二维数组
• y[0]=x; //true y[0]是 一维数组 ，x是一维数组
• y[0][0]=x;//false y[0][0]是具体的数值，x是一维数组
• x[0][0]=y;//fasle x[0][0]不存在，y是二维数组
• y[0][0]=x[0];//true y[0][0]是具体的数值，x[0]是具体的数值
• x=y; //false x是一维数组，y是二维数组

一维数组：int[ ] x或者int x[ ]
二维数组：int[ ][ ] y或者int[ ] y[ ] 或者int y[ ][ ]

数组中涉及的常见算法

• 求数组元素的最大值，最小值，总和，平均数

int[] arr=new int[]{4,2,7,1,3,5};

//max
int max=arr[0];//假设arr[0]为最大值

//min
int min=arr[0];//假设arr[0]为最小值

//sum总和
int sum=0;

for(int i=0;i<arr.length;i++){
	if(max<arr[i]{
		max=arr[i];//存放目前的最大值
	}
	if(min>arr[i]){
		min=arr[i];//存放目前的最小值
	}
	sum+=arr[i];	
}
System.out.println("max:"+max);
System.out.printn("min:"+min);
System.out.println("sum:"+sum);
System.out.println("平均数：“+（sum?arr.length));//求平均数

• 数组的复制(不是赋值），反转

int[] arr=new int[]{4,2,7,1,3,5};
int[] copy=new int[arr.length];//声明一个长度与arr一样的数组
for(int i=0;i<arr.length;i++){ //复制
	copy[i]=arr[i];//遍历arr,把arr的每一个元素按照顺序拿出来，给copy的每一个元素赋值，这里的i就是copy和arr数组的元素下标
}
//反转
//考虑声明一个数组temp，temp的长度与arr的长度一致，我们倒着循环arr，正着给temp元素赋值。 
//temp[0]=arr[5]……temp[3]=arr[2],temp[4]=arr[1]temp[5]=arr[0]
//temp就是arr的倒序的数组，然后再把temp赋值arr(arr=temp)
//一个数组的最后一个元素，它的下标等于数组的长度-1，元素的下标从0开始
int[] temp=new int[arr.length];
int k=0;//这个就是temp的元素下标
for(int i=arr.length-1；i>=0;i--){
	temp[k]=arr[i];
	k++;
}
arr =temp;
for(int i=0;i<arr.length;i++){
	System.out.prinln(arr[i]);
	}

• 数组元素的排序
  • 插入排序
    • 直接插入排序，拆半插入排序，Shell排序
  • 交换排序
    • 冒泡排序，快速排序（或分区交换排序）
  • 选择排序
    • 简单选择排序，堆排序
  • 归并排序
  • 基数排序

冒泡排序

排序思想：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似的操作。

//将 4，7，3，1倒序交换
//4，7，3，1
//4，3，7，1
//4，3，1，7   第一轮得到最大的数字
//3，4，1，7    
//3，1，4，7   第二轮得到除最后一个数字之外的最大的数字
//1，3，4，7   第三轮得到除最后两个数字之外的最大的数字

int[] arr=new int[]{4,7,3,1};
int temp=0;
for(int i=0;i<arr.length-1;i++){//外层循环是循环轮次，轮次循环的次数是数组长度-1
	for(int j=0;j<arr.length-1-i;j++){//每一轮次的数字对比 排序,每轮次的循环依次是4，3，2，轮次长度-1-i
		if(arr[j]>arr[j+1]){//如果要是两个相邻的元素，前面的大于后面，前后两个值交换	
		//正序与倒序排序，其他的都是一致的，在判断两个相邻的元素在声明情况下做交换不一样
		//如果是正序，前面大于后面，交换
		//如果是倒序，前面小于后面，交换	
			temp=arr[j];
			arr[j]=arr[j+1];
			arr[j+1]=temp;
		}
	}
}
for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);
}

数组操作常见问题

编译时，不报错！！！

数组下标越界异常（ArrayindexOutOfBoundsException)
int[ ] arr=new int[2];
System.out.prinln(arr[2]);
访问到了数组中的不存在的脚标时发生

空指针异常（NullPointerException)
int[] arr=null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时

作业

使用简单数组

• 创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数据。
• 使用大括号{}，把array1初始化为8个素数：2，3，5，7，11，13，17，19
• 显示array1的内容
• 赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]，array[2]=2)。打印出array1
• 思考：array1和array2什么关系？
• 拓展：修改题目，实现array2对array1数组的复制

public class TestArray{
	public static void main(String[] args){
		int[] array1=new int[]{2,3,5,7,11,13,17,19};
		int[] array2=new int[]{};
		for(int i=0;i<array1.length;i++){
 			System.out.print(array1[i]+"\t");
		}
		System.out.println("");
		array2=array1;
		for(int j=0;j<array2.length;j++){
 			if(j%2==0){
  				array2[j]=j;
			 }
		 System.out.print(array2[j]+"\t");
		}
	}
	//复制
	/* int array2=new int[array1.length];
	int k=0;
	for(int i=0;i<array1.length;i++){
	array2[k]=array1[i];
	k++;
	}*/
}