【Java复习记录】数组

概述

一维数组
二维数组
算法：利用二维数组输出一个杨辉三角
算法：对数组随机赋值，且元素的值各不相同
算法：回型数

算法：将arry1赋值给arry2
算法：将arry1复制给arry2
算法：数组元素的反转

算法：线性查找
算法：二分法查找

算法：冒泡排序
算法：快速排序

一、一维数组

//1.声明和初始化
int[]arr1= {1,11,111};//静态初始化1
int[]arr1_1=new int[] {1,11,111};//静态初始化2
int[]arr2=new int[5];//动态初始化

//2.数组元素默认初始化值
整型   浮点型           char型             boolean型    引用数据类型
 0      0.0   （0或 ’\u0000' ，而非 ‘0’）    false         null

二、二维数组

//1.声明和初始化
int[][]arr1={{1,2,3},{4,5,6},{7,8,9}};//静态初始化1
int[][]arr2=new int[][]{{1,2,3},{4,5,6},{7,8,9}};//静态初始化2
int[] arr3[]=new int[][]{{1,2,3},{4,5,6},{7,8,9}};//静态初始化3
int[][]arr4=new int[4][3];//动态初始化1
int[][]arr5=new int[5][];//动态初始化2

//2.二维数组元素初始化值
/*针对动态初始化方式一，如：int[][]arr4=new int[4][3];
 *外层初始化 为 地址值
 *内层初始化 与一维数组相同
 *针对动态初始化方式二，如：int[][]arr5=new int[5][];
 *外层初始化 为 null
 */

//3.二维数组的遍历（两层for循环）
for(int i=0;i<arr.length;i++) {
	for(int j=0;j<arr[i].length;j++) {
		System.out.print(arr[i][j]+" ");
	}
	System.out.println();
}

1 2 3 4 
2 1 1 1 
1 1 1 1 

三、算法

3.1利用二维数组输出一个10行的杨辉三角
【提示】从第三行开始，对于非第一个元素和非最后一个元素，
即：yanghui [ i ][ j ]=yanghui [ i-1 ][ j-1 ]+yanghui [ i-1 ][ j ]

int[][]arr=new int[10][];

//先把每一行的第一个和最后一个的1输出
for(int i=0;i<arr.length;i++) {
	arr[i]=new int[i+1];//给二维数组设定每一行的列数
	if(i==0) {arr[i][0]=1;}
	else{arr[i][0]=1; 
		 arr[i][i-1]=1;}
}
//再输出中间的数
for(int i=0;i<arr.length;i++) {
	for(int j=1;j<arr[i].length-1;j++) {
		arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
	}
}
for(int i=0;i<arr.length;i++) {
	for(int j=0;j<arr[i].length;j++) {
	System.out.print(arr[i][j]+" ");	
	}
	System.out.println();
}

1 
1 0 
1 1 0 
1 2 1 0 
1 3 3 1 0 
1 4 6 4 1 0 
1 5 10 10 5 1 0 
1 6 15 20 15 6 1 0 
1 7 21 35 35 21 7 1 0 
1 8 28 56 70 56 28 8 1 0 

方式一

先输出arr1，赋值arr2变量等于arr1，修改arr2中的偶索引元素，使其等于索引值(如arr[0]=0,arr[2]=2),打印出arr1

int[]arr1=new int[]{2,3,5,7,11,13,17,19};
int[]arr2;

for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+" ");
}
System.out.println();
arr2=arr1;//赋值，赋的是地址值，堆空间中只有一个这样的数组

for(int i=0;i<arr2.length;i++) {
	if(i%2==0) {
		arr2[i]=i;
	}
}

for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+" ");
}
//所以处理过arr2后打印arr1，也被改变了

2 3 5 7 11 13 17 19 
0 3 2 7 4 13 6 19 

int[]arr1=new int[]{2,3,5,7,11,13,17,19};
int[]arr2;

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

//复制，是arr1和arr2分别是地址值不同的两个数组
arr2=new int[arr1.length];//是一个新的数组，要new
for(int i=0;i<arr2.length;i++) {
	arr2[i]=arr1[i];
}

for(int i=0;i<arr2.length;i++) {
	if(i%2==0) {
		arr2[i]=i;
	}
}

for(int i=0;i<arr1.length;i++) {
	System.out.print(arr1[i]+" ");
}

2 3 5 7 11 13 17 19 
2 3 5 7 11 13 17 19 

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

//反转
for(int i=0;i<arr1.length/2;i++) {//可再测试i<arr.length时交换了两次，与原数组相同
	int temp=arr1[i];
	arr1[i]=arr1[arr1.length-i-1];//i到length/2，要交换的元素序号和是个常数=length-1
	arr1[arr1.length-i-1]=temp;
}
for(int i=0;i<arr1.length;i++) {
System.out.print(arr1[i]+" ");
}

5 4 3 2 1

通过遍历

String[]arr1=new String[]{"A","B","C","D","E"};

//线性查找3
String goal="E";
boolean isTrue=false;

for(int i=0;i<arr1.length;i++) {
	if(goal.equals(arr1[i])) {//equals比的是内容
		isTrue=true;
		System.out.println("元素E在数列中的序号是"+i);
		break;//找到以后结束循环
	}
}
if(isTrue==false) {//必须在for循环外输出没有找到，但是没有限制条件一定会输出，所以用isFlag
	System.out.println("没有找到");
}

数组必须有序，通过与中间的数比较大小来判断范围

int[]arr1=new int[]{-98,-43,-12,11,111};//数组必须有序

//二分法查找
int goal=-98;
boolean isTrue=false;

//通过索引来截取数组
int start=0;//初始首索引
int end=arr1.length-1;//初始尾索引

while(start<=end) {
	
	int mid=(start+end)/2;
	
	if(goal==arr1[arr1.length/2]) {
		System.out.println("找到了，索引是"+mid);
		isTrue=true;
		break;
	}
	if(goal>arr1[mid]) {//先判断在右边
		start=mid+1;//改索引,end不变
		
	}
	else if(goal<arr1[mid]) {//在左边	
		end=mid-1;//改索引,start不变
	}
}		


if(isTrue==false) {//必须在for循环外输出没有找到，但是没有限制条件一定会输出，所以用isFlag
	System.out.println("没有找到");
}

对每一对相邻元素做同样的工作，将他们作比较，如果他们顺序错误就交换过来

//冒泡排序
int[]arr={99,45,36,11,43,20,12};
/*        45,36,11,43,20,12,99
 *        36,11,43,20,12,45
 *        11,36,20,12,43
 *        11,20,12,36
 *        11,12,20
 *        11,12
 */

//先一大轮地循环，循环arr.length-1次,可以通过举例观察到
for(int i=0;i<arr.length-1;i++) {
	//再将相邻的两个数比较，可以通过举例观察到每一大轮最大的数都会排到最后，所以每一大轮相邻的比较次数都会减少一次
	for(int j=0;j<arr.length-1-i;j++) {
		if(arr[j]>arr[j+1]) {
			int temp=arr[j+1];
			arr[j+1]=arr[j];
			arr[j]=temp;
		}
	}
}
for(int i=0;i<arr.length;i++) {
	System.out.print(arr[i]+" ");
}

11 12 20 36 43 45 99