数组的定义、格式、初始化以及相关操作和源码（数组遍历、数组逆序、求最大/最小值、基本查找、高级排序：冒泡）

一.数组静态初始化 – 格式

*指定的元素内容,系统默认长度.
*格式:
	**标准格式:
	数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,...};
	数据类型 数组名称[] = new 数据类型[]{元素1,元素2,...};
	**简写格式:
	数据类型[] 数组名称 = {元素1,元素2,...};
	数据类型 数组名称[] = {元素1,元素2,...};

二.数组异常

*数组角标越界异常java.lang.ArrayIndexOutOfBoundsException:
	出现原因:访问了数组中不存在的角标值!
	解决方案:更改角标在范围之内. 
*空指针异常java.lang.NullPointerException
	**出现原因:代码结构不严谨(某个对象已经为空)
	**解决方案:需要给该对象进行非空判断!

三.数组的应用(一维数组)

1)遍历

*将数组中元素一一打印输出出来.
*数组中提供属性:length(获取数组中的长度)(数组名.length)

2)求最大/最小值

/*
	数组求最大值,最小值
	分析:
		1)定义数组,静态初始化
		2)定义一个参照物,数组中的第一个元素(它就是一个最大值)
		3)从角标1遍历后面的元素,获取到每一个元素
			判断:
				如果后面的元素都大于max了,
				将该元素赋值max
		4)输出max值
*/
import java.util.Scanner;

class MaxMinDemo{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数组长度 : ");
		int length = sc.nextInt();
		int[] arr = new int[length] ;
		System.out.println("请输入数元素 : ");
		for(int i = 0; i < arr.length ; i ++){
			arr[i] = sc.nextInt();
		}
		int max = max1(arr);
		int min = min1(arr);
		System.out.println("数组中最大值为 : " + max + "最小值为 : " + min);
		
	}
	public static int max1(int[] array){
		int max = array[0];
		for(int i = 1; i < array.length ; i++){
			if(max < array[i]){
				max = array[i] ;
			}
		}
		return max;
	}
	public static int min1(int[] array){
		int min = array[0];
		for(int i = 1; i < array.length ; i++){
			if(min > array[i]){
				min = array[i] ;
			}
		}
		return min;
	}
}

3)数组逆序

/*
	数组逆序.
*/
import java.util.Scanner;

class ArrayDemo{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("输入数组长度 : ");
		int len = sc.nextInt();
		int array[] = new int[len];
		System.out.println("请输入数组元素 : ");
		for(int i =0; i < array.length ; i++){
			array[i] = sc.nextInt();
		}
		revser(array);
		arrayArr(array);
	}
	public static void revser(int[] array){
			int num = 0;
		int n = array.length - 1;
		for(int x =0; x < array.length ; x++){
			if(n<x){
				break;
			}              
			num = array[x];
			array[x] = array[n];
			array[n] = num;
			n--;
		}	
	}
	public static void arrayArr(int[] array){
		for(int y = 0;y < array.length ; y++){
			System.out.print(array[y] + "\t");
		}
	}
}

4)数组基本元素查找

*通过数组的角标值确定内容.

*从数组中的开始索引一直查询到末尾,查询出元素第一次在数组中的索引值.
数组的基本查找法:(数组的元素内容可以无序)

*从数组中的开始索引一直查询到末尾,查询出元素第一次在数组中的索引值
	**数组的高级查找:二分搜索法(折半查找): 前提条件:数组的元素必须有序!

5)数组高级排序:冒泡

*冒泡思想:两两比较,将较大的值往后放,第一次比较完毕,最大值出现在
最大索引处,依次这样比较...

*规律:两两比较,将较大的值往后放总共比较的次数:数组长度-1次

*代码:/*
	冒泡排序,二撸代码
*/
import java.util.Scanner;

class BubblingDemo{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数组长度 : ");
		int length = sc.nextInt();
		int[] arr = new int[length];
		System.out.println("请依次输入数组元素 : ");
		for(int i = 0 ; i < arr.length; i++){
			arr[i] = sc.nextInt();
		}
		ergodic(arr);//冒泡之前进行数组遍历
		bubbling(arr);//调用冒泡算法
		System.out.println();
		ergodic(arr);//冒泡之后进行数组遍历
	}
	//方法实现冒泡排序
	public static void bubbling(int[] arr){
		int num = 0;
		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]){
					num = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = num;
				}
				
			}
		}
	}
	//数组遍历
	public static void ergodic(int[] arr){
		System.out.print("[ ");
		for(int i = 0; i < arr.length ; i ++){
			System.out.print(arr[i] + ", ");
		}
		System.out.print("]");
	}
}

6)面试题

*数组中有没有length属性,字符串中有没有length属性,集合中有没有length属性:
	**数组中有length属性
	**字符串中没有length属性:String类中有:length();
	**集合中没有length属性:集合中:size();

四.二维数组(了解)

1)概念

就是一个元素为一维数组的数组

2)定义格式

数据类型[] 数组名称[];
数据类型[][] 数组名称;

3)动态初始化

格式一:
	数据类型[][] 数组名称 = new 数据类型[m][n];
格式二:
	**数据类型[][] 数组名称 = new 数据类型[m][];
	**指定了一维数组的个数,一维数组的长度需要动态给定.

4)静态初始化

格式三:
	**数据类型[][] 数组名称 = new 数据类型[][]{{元素1,元素2,...},{元素1,元素2,...},...};
简写格式:
	**数据类型[][] 数组名称 = {{元素1,元素2,...},{元素1,元素2,...},...};

5)二维数组的遍历

/*
		二维数组的动态声明，赋值，遍历
*/
import java.util.Scanner;

class TwoDimensionalArrayDemo{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入二维数组的行数 :" );
		int m = sc.nextInt();
		System.out.println("请输入二维数组的列数 :" );
		int n = sc.nextInt();
		int  array[][] =  new int[m][n]; //数组动态初始化
		for(int i = 0;i < array.length;i ++){//使用for循环嵌套输入二维数组元素
			for(int j = 0;j < array[i].length;j ++){
				array[i][j] = sc.nextInt();
			}
		}
		System.out.println("遍历数组进行输出 : ");
		for(int x =0;x < array.length;x ++){
			for(int y = 0;y < array[x].length;y ++){//使用for循环嵌套对二维数组进行遍历
				System.out.print(array[x][y] + "\t");
			}
			System.out.println();
		}		
	}
}