数组介绍（静态，动态初始化）数组的遍历

数组介绍（静态，动态初始化）数组的遍历

1. 数组介绍（静态，动态初始化）
2. 数组的遍历
3. 数组遍历案例
4. 数组中常见的异常

---

数组我们常说的是一维数组，二维数组等等，严格意义来说在java中是没有一维数组的，数据本身就是引用数据类型，是同一种数据类型的集合，就是一个容器。
使用数组的好处是可以给数组中的元素进行自动编号，方便我们可以操作这些数组。
对数组的定义我们有动态初始化和静态初始化。

使用数组我们的该注意哪些？

1. 数组的下标是从0开始的一直到长度-1
2. 数据没有赋值，是会有初始值的
3. 一旦声明不能改变数组的容量

（动态和静态初始化）使用场景：

类型	使用场景
动态初始化	数组的定义与数组分配空间和赋值是分开进行的 元素个数知道，但是值不知道的时候。 比如级预招生20人，但是每个人的名字不知道
静态初始化	在定义数组的同时分配空间赋值

---

动态初始化
语法格式数据类型[]变量名 = new 数据类型[元素个数]；
结构式分析：

	分析
数据类型	可以是基本数据类型也可以是引用数据类型
[]	特殊的符号，表示一个数组
变量名	只要符合命名规范即可

左边：可以写成数据类型 变量名[]，但我们建议写成常规写法。
右边：new 表示在内存中产生容器的实体，通过new关键字开辟空间，数据类型和左边的类型保持一致。
元素个数：存放值的个数或者信息的个数。

案例

int []arrs = new int[5];
System.out.println(arrs[0]);
System.out.println(arrs[1]);
System.out.println(arrs[2]);
System.out.println(arrs[3]);
System.out.println(arrs[4]);

输出结果为

0
0
0
0
0

下标默认从0开始到长度-1；
在java中，java提供了一种方法可以以数组的形式打印出结果，Arrays.toString()方法.详细方法可见API，java.util包下的Arrays的toString方法，下面为该方法的API截。

int []arrs = new int[5];
System.out.println(Arrays.toString(arrs));

输出的结果为：[0,0,0,0,0]

---

静态初始化
语法格式数据类型[ ]变量名=new 数据类型[ ]{值1，值2，值3....}；
可以简写为：数据类型[ ]变量名={ 值1，值2，值3....}；

案例：

public static void main(String []args){
	String []names=new String[]{"kevin","zhangsan","lisi"}
	System.out.println(names[0]);
}

控制台输出结果为：

kevin

---

静态和动态初始化区别就是：
动态我们知道有多少个，但是具体值不知道，静态我们是直接赋值。我们可以结合不同场景下的条件合理使用两种初始化方式

---

数组遍历
首先我们先通过一个案例来开始我们对数组遍历的学习。

public class Test{
public static void main (String [] args){
	int nums[]={1,2,3,7,5};//静态初始化
	System.out.println(names[0]);
	System.out.println(names[1]);
	System.out.println(names[2]);
	System.out.println(names[3]);
	System.out.println(names[4]);
	}
}

我们发现这样的数组我们还能处理，但是如果有1000个甚至更多，显然这种方法就不可取了。为了解决这种情况，我们引入了对数组的遍历。

什么是数组的遍历？
数组的遍历就是依次查询数组中的元素信息，不会多查也不会少查当然也不会发生错乱。

在数组中，我们知道输出System.out.println(names[0]);就是进行输出数组中第一个元素信息，我们同样也知道数组的长度是0到n-1，那么如何来表达这个长度呢，java中有个length方法，可以有效的解决这个问题。我们用数组名.length来获取数组的长度。

主要的遍历方式： for循环和foreach

for循环遍历数组案例：

public static void main (String []args){
	int nums[]={1,2,3,7,5};
	//数组的遍历
	for(int i = 0;i<=nums.length-1;i++){//0 1 2 3 4
	//输出打印当前数组所在的元素信息
	System.out.println(nums[i]);
	}
}

当然我们也可以通过前面学习的函数来进行打包成独立的函数方法。

/*
*分析：返回值 void
*		函数名称 query
*		位置内容的参与 int []arrs
*/
public static void query(int [] arrs){
	for(int i = 0;i<=nums.length-1;i++){
	//输出打印当前数组所在的元素信息
	System.out.println(nums[i]);
}

public static void main (String []args){
	int nums[]={1,2,3,7,5};
	query(nums);//通过函数名直接调用处理
}

for循环遍历数组的使用场景：
一般主要用在查询，后续对数组需要进行修改，删除，改写，建议。

---

foreach是for循环的加强版，是JDK5.0后的加的新的循环类型，被称之为加强版循环，可以在不使用下标的情况下，遍历数组。
foreach的结构体：

for（数据类型 变量名：要遍历的数组）{
	输出语句（变量名）；
}

数据类型：要遍历数组的数据类型；
变量名：存放临时值的容器；

foreach循环遍历数组案例：

public static void query(int[]nums){
	for(int n:nums){
		System.out.println(n);
	}
}

主函数：

public static void main (String []args){
	int nums[]={1,2,3,7,5};
	query(nums);//通过函数名直接调用处理
}

---

下面我们会写几个关于数组遍历的案例，进行深入学习数组的遍历。
案例1：获取数组中的元素相加求和

public static void main (String []args){
	//定义数组
	int [] nums={12,24,23,15,17,98};
	int sum = add(nums);
	System.out.println(sum)
	}
	
	/*
	*获取数组中的元素相加求和
	*分析：
	*1.返回值类型	int
	*2.函数名称	add
	*3.参数列表（未知内容参与）int [] arrs
	*/
	public static int add(int []arrs){
	/*
	*1.定义变量存放 和 信息	int sum
	*2.依次遍历数组拿到每个值信息，把拿到的值信息加入到sum中
	*3.返回结果值给调用方
	*/
		int sum=0;
		for(int i = 0;i <=arrs.length;i++){
		//System.out.println(arrs[i]);//每次遍历到的值信息
		
		sum+=arrs[i];//把遍历到的值加入到sum变量中去
	}
		return sum;
}

---

案例2：随机生成10个1-20之间的整数，然后进行相加求和
分析：这个我们只知道元素个数是10个，不知道值信息，所以用数组的动态初始化。
随机数：javaApi中的lang包中有个方法为Math类（基本数学运算的方法）.random(),详细可看API，下图为API中详解：

由API中的范围结合题目范围为1-20，所以我们需要乘以20，这是的结果值为：1.0-20.0之间，小于20.0，所以我们需要+1，让该范围成1.0-21.0之间，也就是20.9999999~，然后将此转换成int类型，使后面的精度丢失成1-20.

（int）（Math.random（）*20）+1

利用随机工具生成10个整数，依次放入到数组中去；

public static void main (String []args){
	//定义变量 数组对象
int []numbers= new int[10]; //动态初始化
	//随机赋值
for(int i = 0;i<=numbers.length;i++){
	//随机进行赋值
	int num=(int)(Math.random()*20)+1;
	numbers[i]=num;//将每次随机到的值传入数组numbers中
}
	//遍历
	//System.out.println(Arrays.toString(numbers));
	int sums=add(numbers);
	System.out.println(sums);
	}

由了上面的操作，我们就会得到一个容量大小为10且里面已经随机传入元素值的数组。接下来我们只需要写个功能函数进行数组相加求和即可。这里可以使用上面的add

/*
	*获取数组中的元素相加求和
	*分析：
	*1.返回值类型	int
	*2.函数名称	add
	*3.参数列表（未知内容参与）int [] arrs
	*/
	public static int add(int []arrs){
	/*
	*1.定义变量存放 和 信息	int sum
	*2.依次遍历数组拿到每个值信息，把拿到的值信息加入到sum中
	*3.返回结果值给调用方
	*/
		int sum=0;
		for(int i = 0;i <=arrs.length;i++){
		//System.out.println(arrs[i]);//每次遍历到的值信息
		
		sum+=arrs[i];//把遍历到的值加入到sum变量中去
	}
		return sum;
}

---

案例3：获取数组中的最小值，该数组为键盘输入值
案例题解析：获取键盘输入，我们可以通过javaApi提供的util包下的Scanner来获取用户输入的文本信息，下图为api详解：

/*
*获取数组的最小值，该数组为键盘输入值
*分析：1.定义数组
*2.假设一个最小值
*3.依次遍历和我们假设的最小值进行比较
*4.输出打印最小值
*/
public static void main (String []args){
	//定义变量 数组对象
int []nums= new int[7]; //动态初始化
	//实例化类对象，为获取键盘输入的值做准备
	Scanner ner = new Scanner(System.in);
for(int i = 0;i<=numbers.length;i++){
	//提示信息
	System.out.println("请输入您的第"+i+"个值：")；
	//获取值信息
	int a =ner.nextInt();
	nums[i]=a;//把获取键盘输入的值传入到数组nums中去

	//获取最小值
	int min[]=getMin(nums);
	System.out.println(min);
		}
	}

这里我们可以使用前面我们用到的Arrays.toString()方法输出打印出来.
在写一个函数方法来处理比较大小的功能，获取最小值，用来给调用方调用。

/*获取数组中的最小值
*分析：
*返回值类型	int
*函数名称	getMin
*参数列表	int arrs[]
*/
public static int getMin(int[]arrs){
	/*
	*功能分析：
	*1.定义变量，记住数组最小的值
	*2.遍历数组，把数组中的每个元素和定义的最小值进行比较
	*3.当遍历一遍之后，最小值产生，返回给调用方
	*/
	//定义变量，存放最小值
	int min =arrs[0];
	//遍历比较
	for(int i = 0; i <=arrs.length;i++){
	if(min>arrs[i]){//如果假设的最小值大于遍历的值，把最小值变量改为遍历的值
	min= arrs[i];
	}
}
return min;
}

---

数组中常见的异常
1.数组的下标越界（ArrayIndexOutofBoundsException）
看到这个异常，我们需要考虑的两个点：是否向上越界或者向下越界。
主要看：看初始值和length范围。
例如初始值为0，长度为5。下标编号就是0，1，2，3，4，如果我们输出编号5就是越界。
2.空指针（NullPointerException）
空指针表示没有任何对象的引用。

public static void mian(String[]args){
	//定义int类型数组
	int[] x = {1,2,3,4};
	System.out.println(x[1]);
	//把x重新引用对象
	x=null；
System.out.println(x[1]);
}

当x=null的时候，表示没有任何引用了，就会报空指针异常。

---

后面我们的博文会接着数数组中的内存解析（堆栈分析），以及数组冒泡排序。
数组的内存解析堆栈分析（值传递，地址传递）
冒泡排序