数组

数组概述

1)数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
2)数组既可以存储基本数据类型，也可以存储引用数据类型。

数组的定义格式：
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：针对数组定义两种格式，推荐使用第一种格式。因为第一种的可读性更强。第二种可以早期的时候确实有很多人这样用。不过，现在这样用的人越来越少了。作为Java的粉丝C#(Java的模仿者)就不再支持第二种语法格式了。越来越多的语言可能会抛弃第二种格式。

数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

Java中的内存分配

1. Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
   
   1. 栈 存储局部变量
   2. 堆 存储new出来的东西
   3. 方法区（面向对象部分讲）
   4. 本地方法区（和系统相关）
   5. 寄存器（给CPU使用）
   

静态初始化

格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法--->int[] arr = {1,2,3};

数组中常见的小问题：
1）数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
**出现的原因:**
访问了数组中不存在的角标值
**解决方案:**
更改角标在范围内即可!
2）空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素时
**出现的原因:**
				代码结构不严谨(某个对象已经为null,还有使用这个对象调用方法或者访问元素...)
**解决方案:**
				只要 给对该对象进行非空判断
				如果该对象不为空,才能使用这个对象完成一些操作!

为什么要记住这些小问题？
因为写程序不仅仅是把代码写出来，还包括出现问题后要能够及时的把问题解决。而排错也应该是我们的基本功。所以，我们也应该记住一些常见的问题，以及出错原因和解决方案。

面试常见问题1：

数组中有没有length属性，字符串有没有length属性，集合中有没有？
答：数组中存在length属性。
字符串没有length属性--->String类中：length()
集合没有length属性--->集合中：size()

数组的应用——遍历

遍历:就是将元素的内容一一输出出来!

class ArrayTest{
	public static void main(String[] args){
		//定义一个数组,静态初始化
		int[] arr = {57,69,80,13,22} ;
		printArray2(arr) ;
	}
	//最终版代码:遍历数组
	public static void printArray2(int[] array){
		//拼接左中括号
		System.out.print("{") ;
		//遍历array数组
		for(int x = 0 ; x < array.length; x ++){//x角标
			//获取到每一个元素
			//判断:如果x取到最大索引值,---->取到最后一个元素了
			if(x==array.length-1){
				//最后一个元素,输出元素内容以及右中括号
				System.out.println(array[x]+"}") ;
			}else{
				//不是取到最大索引值,将中间的元素按照按照格式输出(元素+逗号+空格)
				System.out.print(array[x]+", ") ;
			}
		}
	}
}

数组中的冒泡排序法

两两比较，大的值往后放，第一次比完最大值就出现在最大索引处，依次比较，可以得到一个排好序的数组。
比较次数：数组长度-1—>length-1
代码如下：

class Test5{
	public static void main(String[] args){
				int[] arr={12,54,66,21,36};
				printArray(arr);
				maoPao(arr);
				printArray(arr);		
	}
	public static void printArray(int[] arr){
		System.out.print("[");
		for(int x=0;x<arr.length;x++){
			if(x==arr.length-1){
				System.out.println(arr[x]+"]");
			}else{
				System.out.print(arr[x]+", ");
			}
		}
	}
		public static void maoPao(int[] arr){
			for(int i=0;i<arr.length;i++){
				for(int j=0;j<arr.length-1-i;j++){
					if(arr[j]>arr[j+1]){
						int temp=arr[j];
						arr[j]=arr[j+1];
						arr[j+1]=temp;
					}
				}
			}
		}
}

二维数组

二维数组:
			其实就是一个元素为一维数组的数组	
	定义格式:
	数据类型[] 数组名称[] ;
	数据类型[][] 数组名称 ;
	动态初始化:
		**二维数组的格式1:**
			数据类型[][] 数组名称 = new 数据类型[m][n] ;
		举例:
			 **int[][] arr = new int[3][2] ;**
		=号左边:
			int:当前数组存储的是int类型的元素
			[][]:定义的是一个二维数组
			arr :数组对象名称
		=号右边:
			new :在堆内存中创建该数组的对象(产生堆内存空间地址)
			int:当前数组存储的是int类型的元素

		[3]: 当前定义的这个二维数组中有3个一维数组
		[2]: 每一个一维数组中有2个长度

注意:
		在一些笔试题:定义变量 进行初始化
			int x, y ;  x 和y是两个int类型的变量
			int x [],y[] ;x和y都是int类型的数组
			int x[][],y[] ; x是一个二维数组,y是一个一维数组

**

二维数组的格式2:**
	指定了一维数组的个数,一维数组的长度需要动态给定
	数据类型[][] 数组名称 = new 数据类型[m][] ;
	举例:
		int[][] arr = new int[3][] ;
	**二维数组的格式3:**
		就是静态初始化
		数据类型[][] 数组名称 =
				new 数据类型[][]{{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
		简写格式:
	数据类型 [][] 数组名称 = {{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
		举例：
			int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;
			--->简写格式       int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;

二维数组的遍历：

/*
	二维数组的遍历
	
	外层循环:其实是一维数组的个数(arr.length)
	内层循环:其实每一个一维数组的长度(arr[x].length)
	
	最终让你以:{{1,2,3},{4,5},{6}}按照这个格式
	
*/
	
	   

class Array2Test{
	public static void main(String[] args){
		
		//定义一个二维数组,静态初始化:
		int[][] arr = {{1,2,3},{4,5},{6}};  
	
		//调用遍历的功能
		printArray2(arr) ;
	}
	/*
		两个明确
			1)明确返回值类型:void
			2)明确参数类型以及参数个数
				1个参数 int类型二维数组
					
	*/
	public static void printArray2(int[][] arr){
		//输出以下左大括号
		System.out.print("{");
		//遍历
		for(int x = 0 ; x < arr.length; x++){//外层循环是一维数组的个数
			//先输出左大括号
			System.out.print("{");
			//遍历一维数组的元素
			for(int y = 0 ; y < arr[x].length ; y++){
				//判断
				//如果是二维数组的最后一个元素
				if(x == arr.length-1){
					//输出元素值以及后面的}
					System.out.print(arr[x][y]+"}") ;
					
					//如果当前元素取到的一维数组的最后一个元素
				}else if(y == arr[x].length-1){
					//输出元素内容以及}以及,
					System.out.print(arr[x][y]+"}"+",") ;
				}else{
					System.out.print(arr[x][y]+",") ;
				}
			}
			
		}
		//输出整个右}
		System.out.print("}");
	}
}

二维数组案例杨辉三角打印

/*
     1
    1 1
   1 2 1
  1 3 3 1 
 1 4 6 4 1 
1 5 10 10 5 1		*/
import java.util.Scanner;
class YH{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个数：");
		int rows = sc.nextInt();
		int[][] yh = new int [rows][];
		for( int i = 0 ; i < rows ; i++ )
		{
			yh[i] = new int[i+1];
		}
		for( int i = 0 ; i < yh.length ; i++)
		{
			yh[i][0]=1;
			yh[i][i]=1;
		}
		//计算
		for(int i = 2 ; i < yh.length; i++ ){
			for( int j = 1 ; j < i ; j++ )
			{
				//当前位置的值 = 上一行的同列 + 上一行的前一个列
				yh[i][j] = yh[i-1][j-1]+yh[i-1][j];
			}
		}
		
		
		for( int i = 0 ; i < yh.length ; i++  ){
			//标准杨辉三角格式打印，如需直角三角形则删除该for循环代码块
			for (int j = rows - 1 ; j > i ; j --){
				System.out.print("\t");
			}
				
			for(int j = 0 ; j < yh[i].length ; j ++)
			{
				System.out.print("\t"+yh[i][j]+"\t");
			}
			System.out.println();
		}
		
	}
}