黑马程序员_数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流------

一维数组

数组的定义: 用来存储多个元素的一个容器
   数组可以存储基本数据类型也可以存储引用数据类型
格式:
格式1: 数据类型[] 数组名 ;
格式2: 数据类型 数组名[] ;


数组的初始化:
(1): 动态初始化  由我们给定数组的长度,由系统来分配初始化值
(2): 静态初始化  由我们给定初始化值,由系统来决定长度


注意事项: 不能进行动静结合

数组的静态初始化:
完整格式: 数据类型[] 数组名 = new 数据类型[]{元素1 , 元素2 , 元素3 ,....}; 
简化格式:   数据类型[] 数组名 = {元素1 , 元素2 , 元素3 ,....};

动态初始化的格式:  
数据类型[] 数组名 = new 数据类型[数组的长度];
数组的长度: 表示的意思就是数组中元素的个数


注意一些方法的错误问题:  ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
NullPointerException:空指针异常

原因：数组已经不在指向堆内存了。而你还用数组名去访问元素

class ArrayTest {

	public static void main(String[] args){
		
		
		// 定义一个int类型的数组,并且对其进行动态初始化
		int[] arr = new int[3];

		// 输出数组名称
		System.out.println(arr);			// [I@da6bf4 :地址值

		/* 
		输出数组中的元素值
		其实java针对数组中的每一个元素为其分配了一个编号,这个编号从0开始,最大编号是数组的长度 - 1 
		那么这个编号有一个专业的名词: 索引 ,那么我们可以使用数组名称配合索引来获取指定的元素
		格式是: 数组名[索引]
		*/
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);

		// 给数组元素赋值
		arr[0] = 56 ;
		arr[1] = 23 ;
		arr[2] = 98 ;

		// 输出数组中的元素值
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

数组的静态初始化:

class ArrayTest2 {

	public static void main(String[] args)  {

		// 定义一个int类型的数组
		// 错误的: 不能进行动静结合
		// int[] arr = new int[3]{1, 2, 3} ;
		
		// 定义一个int类型的数组,并使用静态初始化
		int[] arr = {23, 45, 67, 89} ;

		// 输出数组名称
		System.out.println(arr);

		// 输出元素
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);

		// 给输出元素赋值
		arr[0] = 12 ;
		arr[1] = 90 ; 

		// 输出元素
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);

	}
}

java语言的内存分配
(1): 栈: 存储的都是局部变量
局部变量: 就是在方法定义中或者方法声明上的变量
(2): 堆: 存储都是new出来的东西
特点:
(1): 系统会为每一个new出来的东西分配一个地址值
(2): 系统会为每一个元素赋一个默认的初始化值
byte,short,int,long---  0
float,double ---  0.0
char---  '\u0000'
boolean ---  false
引用数据类型 ---  null
(3): 使用完毕以后就变成了垃圾,等待垃圾回收器对其回收
(3): 方法区(面向对象部分)
(4): 本地方法区(和系统相关)
(5): 寄存器(CPU)


内存图:
一个数组的内存图: 数组在内存中是如何构建的
二个数组的内存图: 每new一次会在堆内存中重新开辟空间
3个引用2个数组的内存图: 栈内存中的多个引用可以指向堆内存中的同一个地址

//数组的常见操作:
		//	(1): 遍历
				public static void print(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] + ", ");
						}
					}
				}
		//	(2): 获取最值
				public static int getMax(int[] arr){
					int max = arr[0] ;
					for(int x = 0 ; x < arr.length ; x++){
						if(arr[x] > max){
							max = arr[x] ;
						}
					}
					return max ;
				}
		//	(3): 反转
				public static void reverseArr(int[] arr){
					for(int x = 0 , y = arr.length - 1 ; x <= y ; x++ , y--){
						int temp = arr[x] ;
						arr[x] = arr[y] ;
						arr[y] = temp ;
					}
				}
		//	(4): 查表法
		//	(5): 基本查找(查找某一个元素在数组中第一次出现的索引)
				
				public static int getIndex(int[] arr , int value){
					for(int x = 0 ; x < arr.length ; x++){
						if(arr[x] == value){
							return x ;
						}
					}

					return -1; 
				}

				public static int getIndex2(int[] arr , int value){
					int index = -1 ;
					for(int x = 0 ; x < arr.length ; x++){
						if(arr[x] == value){
							index = x ;
							break ;
						}
					}
					return index ;
				}

二维数组
第一种经典格式:
数据类型[][] 数组名 = new 数据类型[m][n];
m: 在这个二维数组中有m个一维数组
n: 每一个一维数组的长度是n

非经典格式:
数据类型 数组名[][] = new 数据类型[m][n];
数据类型[] 数组名[] = new 数据类型[m][n]; 
第二种格式:
数据类型[][] 数组名 = new 数据类型[m][];
m: 在这个二维数组中有m个一维数组
而我们的每一个一维数组可以动态给出


第三种格式:
数据类型[][] 数组名 = new 数据类型[][]{{元素...} ,{元素 ....} ,{元素...}....};
简化格式:
数据类型[][] 数组名 = {{元素...} ,{元素 ....} ,{元素...}....};

//遍历二维数组的方法
			public static void print(int[][] arr){
				for(int x = 0 ; x < arr.length ; x++){
					for(int  y = 0 ; y < arr[x].length ; y++){
						System.out.print(arr[x][y] + "\t");
					}
					System.out.println();
				}
			}

******************重点:***************

java语言中的参数传递问题


基本数据类型的参数传递,形式参数的改变对实际参数没有影响
引用数据类型的参数传递,形式参数的改变对实际参数是有直接影响的


java中只有值传递,没有址传递