数组总结

1.数组动态初始化

格式：数据类型[] 数组名称=new 数据类型[元素个数]；

2.数组静态初始化

指定元素的内容，系统默认长度

格式：数据类型[] 数组名称=new 数据类型[] {元素1，元素2，元素3……}；
简写方式：数据类型[] 数组名称={元素1，元素2，元素3……}；

3.数组中会出现的异常

---

异常：Throwable 类
异常分为两大类：
    Error：程序出现了严重的问题
    Exception:RuntimeException:运行时期异常（代码结构不严谨）
数组下标越界异常（属于运行时期异常）：Java.lang.ArrayIndexOutOfBoundsException
        解决方案：更改下标在规定的范围内即可
    空指针异常：NullPointException（运行时期异常）（引用类型：经常开发中会遇到异常）
        解决方案：只要对该对象进行一个非空判断，如果该对象不为空，才可以使用此对象
     编译时期异常：只要不是RuntimeException，就是编译时期异常

4.数组的应用

4.1遍历：将元素的内容一一输出出来

遍历的功能（方法）：定义一个方法
两个明确：
1.明确返回值类型：void
2.明确参数类型以及参数格式（传入一个数组）

import java.util.Scanner;
class ArrayDemo3{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);//创建键盘录入对象
		System.out.println("请输入数组元素的个数：");//提示并录入数据
		int n=sc.nextInt();
		int[] a=new int[n];
		System.out.println("请输入数组元素：");
		a=bianli1(a);
		bianli(a);
	}
	public static int[] bianli1(int[] a){
		Scanner sc=new Scanner(System.in);
		for(int i=0;i<a.length;i++){
			a[i]=sc.nextInt();
		}
		return a;
	}
	public static void bianli(int[] arr){
		System.out.print("遍历结果：[");
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.print("]");
	}
}

4.2数组的最值问题：求最大值/最小值

分析：1.定义数组，静态初始化
2.定义一个参照物（数组的第一个元素）
3.从第二个元素开始遍历，获取到每一个元素，然后依次与参照物比较，将较大/较小的元素赋给参照物
4.输出最大/最小值

	public static int shuchu(int[] a){//判断最值方法
		int temp=a[0];
		for(int i=0;i<a.length;i++){
			if(a[i]<temp){
				temp=a[i];
			}
		}
		return temp;
	}

4.3数组的逆序：倒着打印一遍

特点：将第一个（下标为0的元素）与最后一个（下标为数组.length-1-0）的元素进行交换
要保证遍历的次数小于arr.length/2

	import java.util.Scanner;//导包
	class Reversed{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);//创建键盘录入对象
		System.out.println("请输入数组元素的个数：");//提示并输入
		int n=sc.nextInt();
		int[] a=new int[n];//动态初始化一维数组
		System.out.println("请输入数组元素：");
		for(int i=0;i<n;i++){//循环输入数组元素
			a[i]=sc.nextInt();
		}
		reversed(a);//调用逆序方法
		System.out.print("逆序结果：[");
		for(int i=0;i<n;i++){//循环输出逆序结果
			System.out.print(a[i]+" ");
		}
		System.out.print("]");
	}
	public static void reversed(int[] a){//定义逆序方法
		for(int j=0;j<a.length/2;j++){//将数组中元素进行逆序
			int temp=a[j];
			a[j]=a[a.length-1-j];
			a[a.length-1-j]=temp;
		}
	}
}

4.4数组的基本元素查找法：查找元素中的某一个元素的第一次出现的角标值

通过数组名称[角标值]确定内容

	public static int subscript(int[] a,int n){
		for(int i=0;i<a.length;i++){
			if(n==a[i]){
				return i;
			}
		}
		return -1;
	}

5.数组的高级排序：冒泡排序

思想：两两比较，将较大的值往后放，第一次比较完毕，最大值出现在最大索引处，依次这样比较
规律：两两比较，将较大的值往后放
总共比较次数：数组长度-1次

//冒泡排序
import java.util.Scanner;//导包
class Maopao{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);//创建键盘录入对象
		System.out.print("您想输入的数组的元素个数为：");//提示并输入
		int n=sc.nextInt();//输入数组的元素个数
		System.out.print("输入开始：");
		int[] a=new int[n];//创建一个一维数组
		for(int i=0;i<a.length;i++){//数组下标从0开始
			 a[i]=sc.nextInt();//循环输入数组中的每个元素
		}
		for(int j=0;j<a.length-1;j++){
			for(int k=0;k<a.length-1-j;k++){//第0次有0个不比较；第1次有1个不比较；
				if(a[k]>a[k+1]){//两两比较，将较大的值往后放
					int temp=a[k];//创建一个中间变量，并将大的值赋给中间变量
					a[k]=a[k+1];//将小的值赋给前者
					a[k+1]=temp;//将大的值赋给后者
				}
			}
		}
		System.out.print("最终排序为：");
		for(int s=0;s<=n-1;s++){
			System.out.print(a[s]+" ");
		}
	} 
}

6.二维数组

其实就是一个元素为一维数组的数组
定义：数据类型[] 数组名称[] ;
数据类型[][] 数组名称 ；
格式1:数据类型[][] 数组名称 = new 数据类型[m][n] ;
格式2:指定了一维数组的个数,一维数组的长度需要动态给定
数据类型[][] 数组名称 = new 数据类型[m][] ;
格式3:就是静态初始化
数据类型[][] 数组名称 =new 数据类型[][]{{元素1,元素2,元素3…},{元素1,元素2,元素3,…},{,}};
二维数组的遍历方法

public static void  traverse(int[][] a){
		System.out.print("遍历结果为：[");
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				System.out.print(a[i][j]+",");
			}
			System.out.print("\t");
		}
		System.out.print("]");
	}

二维数组之和

public static int  sum(int[][] a){
		int d=0;
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				 d=a[i][j]+d;
			}
		}
		return d;
	}

杨辉三角

import java.util.Scanner;
class YhTriangle{
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入想要输出的行数：");
		int n=sc.nextInt();	
		int[][] a=new int[n][n];
		for(int i=0;i<n;i++){
			for(int j=0;j<=i;j++){
					if(j==0||i==j){
					a[i][j]=1;
				}else{
				a[i][j]=a[i-1][j-1]+a[i-1][j];	
				}
				System.out.print(a[i][j]+" ");
			}
		System.out.println();
		}
	}
	
}