数组的理解与运用

数组概述

  1. 数组(Array):多个相同类型的数据,按一定顺序排列的集合,并用一个名字命名,通过编号方式统一管理;属于引用数据类型。
  2. ①数组名;②下标(索引):从0开始;③元素 ④数组长度:元素的个数
  3. 特点:①有序排列;②引用数据类型的变量,数组元素可以是基本数据类型变量和引用数据类型变量 ③创建数组,会在内存中开辟一整块连续的空间 ,数组名中引用的是这块空间的首地址;④数组一旦创建,长度不可修改;
  4. 分类:维数分为 一维数组,二维数组
    数组元素类型:基本数据类型,引用数据类型

一维数组的使用

1.一维数组的声明和初始化
①静态初始化:数组的初始化和元素的赋值操作同时进行

int [ ] array=new int [ ] { 0,4,3,5,6,8};

②动态初始化:数组的初始化和元素的赋值操作分开进行

String [ ] names=new String[5];

初始化完成,其长度就确定了。
2.调用指定位置的元素
通过索引的方式调用,从0开始到数组长度 -1 结束

names[0]="王刚“;
names[1]="赵四”;

3.获取数组长度
length 属性

int sum = names.length//元素的个数

4 遍历数组

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

5 数组元素默认初始化值
整型: 0
浮点型: 0.0
char型:0(ascll码值为0)或“ \u000"
布尔型:false
引用数据类型:null
6.数组的内存解析
在这里插入图片描述
在这里插入图片描述

二维数组

理解:一维数组array[]又作为另一个一维数组array1[] 的元素存在;
1.二维数组的初始化
①静态初始化

int [] [] array=new int[][]{{1,2,3},{4,6},{0,5,78,92}};

② 动态初始化

int [][]array=new int[4][5];

2.调用数组元素
首先先理解
外层数组元素:array[3];
内层数组元素:array[1][0];

System.out.print(arry[0][1];//输出为2
System.out.print(arry[2][1]];//输出为5

3.获取数组长度
length属性

System.out.print(array.length);// 3
System.out.print(array[0].length);//3
System.out.print(array[1].length);//2

4.遍历数组元素

for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){//i与j 不同时
System.out.print(array[i][j]+"\t");
}    }

5.数组默认初始值

int [][] array=new int[4][5];

外层元素array[1],array[2] 默认初始值为地址值
内层元素array[0][2],array[2][1] 默认初始值为与一维数组元素类型初始化情况相同;

 int [][] array=new int[4][ ];

外层元素初始化值为null( 元素为数组,引用数据类型默认值为null)
内层元素默认初始化值报错,指针指向错误,空指针
6.内存解析
在这里插入图片描述

数组中常见的算法

1. 数组元素的赋值(杨辉三角,回形数)

1  
1  1  
1  2  1  
1  3  3  1  
1  4  6  4  1  
1  5  10  10  5  1  
1  6  15  20  15  6  1  
1  7  21  35  35  21  7  1  
1  8  28  56  70  56  28  8  1  
1  9  36  84  126  126  84  36  9  1 
 * @Description  杨辉三角
 * @author Mr hlr
 * @date  2020年4月8日上午9:04:38
 */
public class YanghuiTest {
	public static void main(String[] args) {
		//1.定义数组
		int [][] arry=new int[10][];//定义数组
		//2.1给数组元素赋值
		for(int i=0;i<arry.length;i++) {
				arry[i]=new int[i+1];
		//2.2给首末元素赋值
				arry[i][0]=arry[i][i]=1;
				//if(i>1) { //可加可不加
		//2.3给非首末元素赋值
						for(int j=1;j<arry[i].length-1;j++) {
							arry[i][j]=arry[i-1][j-1]+arry[i-1][j];	
						//}
					}
				}
		//3.遍历数组,输出数据
		for(int i=0;i<arry.length;i++) {
			for(int j=0;j<arry[i].length;j++) {
				System.out.print(arry[i][j]+"  ");
			}
			System.out.println();
			}
		}
	}
//创建一个长度为6的int型数组,要求数组元素的值在1-30之间的数,且随机赋值,同时要求元素的值各不相同;
public class ArrayTest {
	public static void main(String[] args) {
		//方法1
//		int [] arr= new int[6];
//		
//		for(int i=0;i<arr.length;i++) {
//			 arr[i]=(int)(Math.random()*30)+1;//产生随机数
//			 
//			 boolean flag=false;//标识
//		while(true) {
//			for(int j=0;j<i;j++) {
//				if(arr[i]==arr[j]) {
//					flag=true; 
//					break;
//				}
//			}
//		
//		if(flag) {//如果为true,重新赋值
//			arr[i]=(int)(Math.random()*30)+1;//产生1-30的随机数
//			flag=false;//改变标识
//			continue;
//		}
//		break;	
//		}
//		}
//		for(int i=0;i<arr.length;i++) {//输出
//			System.out.println(arr[i]);
//		}
		//方法2;
		int [] arr=new int[6];
		for(int i=0;i<arr.length;i++) {
			arr[i]=(int)((Math.random()*30)+1);
			for(int j=0;j<i;j++) {
				if(arr[i]==arr[j]) {//如果相同,i--,重新赋值
					i--;
					break;
				}
			}
		}
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
		
	}
}

2.求数值型数组中元素的最大值最小值平均值,总和""""

3.数组的复制,反转,查找(线性查找,二分查找)

public class Sort {
	public static void main(String[] args) {
		int [] arr=new int[] { 34,5,22,-98,6,-76,0,-3};
				//数组的反转
//		 for(int i=0;i<arr.length/2;i++) {
//			 int temp=arr[i];
//			 arr[i]=arr[arr.length-1-i];
//			 arr[arr.length-1-i]=temp;
//		 }
//		 for(int i=0;i<arr.length;i++) {
//				System.out.print(arr[i]+"\t");
//	} 
//		 System.out.println();
		//数组的复制
//		 int[] arr1=new int[arr.length];
//		 for(int i=0;i<arr.length;i++) {
//			 arr1[i]=arr[i];
//		 }
//		 for(int i=0;i<arr.length;i++) {
//				System.out.print(arr[i]+"\t");
//    }
		//线性查找 更具有
		int dest=0;
  for(int i=0;i<arr.length;i++) {
		if(dest==arr[i]) {
			System.out.println("找到了!位置为:"+i);
			break ;
		}else if(i==arr.length-1) {
			System.out.println("未找到!");
			
		}
	}
		
	}
}

//二分查找
//前提条件:所要查找的数组必须有序
public class BinarySearch {
	public static void main(String [] args) {
		int []find=new int [] {-1,-4,5,43,53,76,86,87,89,90,99,788};//有序数组
		int head=0;//定义首位置
		int end=find.length-1;//末位置
		boolean flag=true;//标识
		int dest=86;//要查找的值
		while(head<=end){	//条件		
			int midol=(head+end)/2;//中间位置
		if(dest==find[midol]) {
			System.out.println("找到了。位置为:"+midol);
			flag=false;
			break;
		}else if(find[midol]>dest) {//要查找的数小于中间位置的数
			end=midol-1;//将中间位置改为末位置

			
		}else {//find[midol]<dest 要查找的数大于中间位置的数
			head=midol+1;//将中间位置改为首位置
		}
	}
		if(flag) {//flag为true说明没有进入到条件判断中
			System.out.println("没有找到哦!");
		}
}
}

4.数组元素的排序算法

目的:快速查找
衡量排序算法的优劣: 时间复杂度,空间复杂度,稳定性
十大内部排序算法
1.选择排序 :直接选择排序,堆排序(O(nlogn)思想
2.交换排序:冒泡排序(On^2) 快速排序(O(nlogn)实现
3.插入排序:直接插入排序, 折半插入排序,Shell排序(希尔排序)
4**.归并排序**(O(nlogn))思想
5.桶式排序
6.基数排序
冒泡排序的实现

//冒泡排序
//思想: 从第一个元素开始,比较两个相邻元素,若前面一个数比后面一个数大,就交换两个数的位置,使较大的数移到数据的右边
import java.util.Scanner;
public class Bubblesort {
	public static void main(String[] args) {
		Scanner reader=new Scanner(System.in);
		System.out.println("请输入五个数:");
		int[] number=new int[5];
		for(int i=0;i<number.length ;i++) {
			 number[i]=reader.nextInt();
		}
		int temp;
		System.out.println("从小到大排序为:");
		for(int i=0;i<number.length-1 ;i++) {//循环次数
			for(int j=0;j<number.length-1-i;j++) {//排序
				if(number[j]>number[j+1]) {//交换
					temp=number[j];
					number[j]=number[j+1];
					number[j+1]=temp;					
				}
			}
		}
		for(int i=0;i<number.length ;i++) {
			System.out.println(number[i  ]);
		}	
	}
}

快速排序思想
选取一个基准元素,然后通过与基准元素比较,将比基准数大的数放在右边,比基准数小的放在左边,划分为两个部分,再分别对两部分作相同的操作。

Arrays的工具类

java.util.Arrays; 操作数组的工具类
常用的几种方法:
boolean equals(int[] a,int[]b) 判断两数组是否相等
String toString (int[] a) 输出数组信息
void fill(int []a,int val) 将指定值填充到数组之中
void sort(int [ ]a) 对数组进行排序
int binarySearch(int [ ] a,int key) 对排序后的数组进行二分法检索指定的值
具体操作:

public class ArrayTest2 {
	public static void main(String[] args) {
		int [] num=new int [] {11,62,31,24};
		int [] bug=new int[] { 34,56,38,2};
		// boolean equals(int[] a,int[]b)  判断两数组是否相等
		boolean isequal=Arrays.equals(num, bug);
		System.out.println(isequal);
		//String toString (int[] a) 输出数组信息
		System.out.println(Arrays.toString(bug));
		//void fill(int []a,int val)  将指定值填充到数组之中
		Arrays.fill(bug, 10);
		System.out.println(Arrays.toString(bug));
		//void sort(int [ ]a) 对数组进行排序
		Arrays.sort(num);
		System.out.println(Arrays.toString(num));
		//int binarySearch(int [ ] a,int key)  对排序后的数组进行二分法检索指定的值
		int [] is=new int [] {-12,-2,0,12,34,45,66,67,80,90};
		int dex=Arrays.binarySearch(is, 0);
		if(dex<0) {
			System.out.println("没有找到!");
		}else
		System.out.println("位置为:"+dex);
	}
}

数组中的常见异常

1.数组角标(索引)越界的异常:ArrayIndexOutOfBoundsException;
2.空指针异常 NullPointerException

情况一
int [] arr=new int []{1,2,3,4};
arr=null;
System.out.print(arr[0]);
情况二
int [] [] arr=new int[3][];
System.out.print(arr[0][0]);
  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值