Day05Java基础之数组和遍历

1. 数组的概述和格式
   （1） 为什么用数组：为了存储同种数据类型的多个值。
   （2） 数组概念：
   数组是存储同一数据类型多个元素的集合。也可以看作一个容器。
   数组既可以存储基本数据类型，也可以存储引用数据类型。
   （3） 数组定义格式：
   数据类型[] 数组名 = new 数据类型[数组的长度]。

class Demo1_Array	{
			public static void main(String[] args)	{
				int [] arr = new int[5];  //可以存储5个int类型的数据
			/* 左边：
			int :代表数据类型 ；
			[]：代表数组，几个中括号就代表几维数组；
			arr ：代表合法的标识符
		
			右边：
			new ：创建新的实体对象；
			int:数据类型；
			[]:代表的数组
			5：代表数组长度
	*/
	}
}

2. 数组的初始化动态初始化
   （1） 什么是数组的初始化：
   就是为数组开辟连续的内存空间，并为每个数组元素赋予值。
   （2） 如何对数组进行初始化
   a. 动态初始化 只指定长度 ，由系统给出初始化值
   int arr = new int[5];
   b. 静态初始化 给出初始化值，由系统决定长度。
   （3） 动态初始化格式：
   数据类型[] 数组名 = new 数据类型[数组的长度]。
   （4） 例：输出数组名称和数组元素

class Demo2_Array	{
	public static void main(String[] args)	{
		int [] arr = new int[5];  //动态初始化，在内存开辟储5块连续空间
		System.out.println(arr[0]);   //系统默认初始值，整数默认为0
		arr[0] = 10；             //自己赋初值
		System.out.println(arr[0]);  
		System.out.println(arr);     //数组名打印出来为[I@19bb25a 
	}
}

（5） 整数类型：byte,short,int.long默认初始化值为0
浮点类型：float,double默认初始化值为0.0
布尔类型：Boolean默认初始化值为false
字符类型：char默认初始化值为’\u0000’
Char在内存中占的两个字节，都是16个二进制位。
\u0000,每个0其实代表的是16进制的0，那么四个0就是代表16个二制位。
[I@19bb25a
[代表数组，几个就是几维
@是固定的
19bb25a代表一个十六进制的地址值。
3. Java中的内存分配以及栈和堆的区别
（1） 栈：存储局部变量
局部变量：定义在方法声明上和方法中的变量。
栈：先进后出
（2） 堆：存储new出来的数组或对象
（3） 方法区：面向对象部分讲解
（4） 本地方法区：和系统相关
（5） 寄存器：给cpu使用

4. 数组的内存图解1 一个数组

5. 数组的内存图解2 两个数组
   
6. 数组的内存图解3 三个引用两个数组
   
7. 数组的静态初始化及其内存图
   （1） 静态初始化的格式
   格式：数据类型[] 数组名 = new 数据类型[] {元素1，元素2，…};
   简化格式：数据类型[] 数组名 = {元素1，元素2，…};

（2） 案例演示
对数组的解释
输出数组名称和数组元素

class Demo1_Array	{
			public static void main(String[] args)	{
				int [] arr = new int[5]{11,22,33,44,55};  //错误声明，不允许静动结合
				int [] arr = new int[]{11,22,33,44,55};  //完整的静态声明格式
				int[] arr2 = {11,22,33,44,55};  //简写形式声明和赋值必须在同一行

				int[] arr;             //声明数组引用
				arr = new int[]{11,22,33,44,55};  

				System.out.println(arr);
				System.out.println(arr[4]);
			}
	}

（3） 画图演示：一个数组

8. 数组操作中的两个常见小问题越界和空指针
（1） 案例演示
A. ArrayIndexOutofBoundsException:数组索引越界异常
原因：你访问了不存在的索引。

	class Demo2_Exception	{
		public static void main(String[] args)	{
			int [] arr = new int[5];
			System.out.println(arr[5]);  //当访问数组中不存在的索引，会出现索引越界异常
		}
	}

B. NullPointerException:空指针异常
原因：数组已经不在指向堆内存了而你还用数组名去访问元素。
int [] arr = {1,2,3};
arr = null;
//当给数组引用赋值为null时，再去调用数组中的元素就会出现空指针异常
System.out.println(arr[0]);
9. 数组的操作1遍历
（1） 数组的遍历：就是依次输出数组中的每一个元素。
（2） 数组的属性：arr.length数组的长度。
（3） 数组的最大索引：arr.length – 1;

class Demo2_Exception	{
	public static void main(String[] args)	{
		int [] arr = {11,22,33,44,55};
		int [] arr2 = {3,4,5};
		print(arr2);
	}
	public static void print(int[] arr)	{
		for(int i = 0;i < arr.length;i++){  //arr.length为数组的长度
		System.out.println(arr[i]); 
		}
	}
}

10. 数组的操作2 获取最值（获取最大值或者最小值）

class Demo3_Exception	{
	public static void main(String[] args)	{
			int [] arr = {11,22,33,44,55};
			int max = getMax(arr);
			System.out.println(max);	
}
		/*
		获取数组中的最大值
	（1）	返回值类型：int
	（2）	参数列表int[] arr
	*/
	pulic static int getMax(int[] arr)	{
		int max = arr [0];   //不给其赋值为0，因为若数组元素都为负，0就是最大了
		for(int i = 1;i < arr.length;i++)	{  //从数组的第二个元素开始遍历
			if(max < arr[i])	{		//如果max记录的值小于数组中的元素
				max = arr[i];		//max记住较大的值
		}
	}
		return max;
}

12. 数组的操作3 反转（就是元素对调）

class Demo4_Array	{
 	public static void main(String[] args)	{
			int [] arr = {11,22,33,44,55};
			reverseArray(arr);
			print (arr);	
}
	public static void reverseArray(int [] arr)	{
		for(i = 0;i < arr.length / 2; i++)	 {
				int temp = arr [i];
				arr[i] = arr[arr.length - 1 - i];
				arr[arr.length -1 - i] = temp;
			}
		}
	public static void print(int[] arr)	{	//数组的遍历，打印数组
			for(int i = 0;i < arr.length;i++){    //arr.length为数组的长度
			System.out.println(arr[i]); 
		}
	}
}

14. 数组的操作5 数组元素查找（查找指定元素第一次在数组中出现的索引）

import java.util.Scanner;
class Demo5_Array	{
	public static void main(String[] args)	{
		int[] arr = {11,22,33,44,55};
		int index = getIndex (arr,88)
		System.out.println(index);
	}
/*
查找元素索引
1,返回值类型int
2，参数列表：int[] arr,int value
*/
public static int getIndex(int[] arr,int value)	{
		for (int i = 0;i < arr.length; i++)	{
			if (arr[i] == value)	{
				return I;
				}
			}
			return -1；
	}
}

15. 二维数组的概述和格式1的讲解
    （1） 二维数组：
    （2） 二维数组的格式：
    Int [] [] arr = new int[3][2];
    （3） 注意事项
    A. 以下格式也可以是二维数组
    a. 数据类型 数组名[][] = new 数据类型[m][n];
    b. 数据类型[] 数组名[] = new 数据类型[m][n];
    B. 注意下面定义的区别

int x;
int y;
int x,y;  //声明两个变量

int[] x;  //声明一个一维数组
int[] y[];  //声明一个二维数组

int[]  x,y[];   //x是一维数组，y是二维数组

（4） 数组演示
定义二维数组，输出二维数组的名称，一维数组名称，一个元素

class Demo1_Array	{
	public static void main(String[] args)	{
		int[][] arr =new int [3][2];//这是一个二维数组，这个二维数组有3个一维数组，每个一位数组的长度为2
		int arr [] [] = new int[3][2];  /同上定义含义
		System.out.println(arr);     //二维数组，输出二维数组的地址
		System.out.println(arr[0]); //二维数组的第一个一维数组，输出该一维数组的地址
		System.out.println(arr[0][0]); //二维数组的第一个一维数组的第一个元素	
		}
	}

14. 二位数组格式1的内存图
    

15. 二位数组格式2的讲解及其内存图
    （1） 二位数组格式2
    Int[][] arr = new int[3] [];

	class Demo2_Array	{
		public static void main(String[] args)	{
		int[][] arr =new int [3][]; //这是二维数组，其中有三个一维数组，且都没有初始化
		arr[0] = new int [3];	//第一个一维数组可以存储三个int值
		arr[1] = new int [5];  //第二个一维数组可以存储五个int值
		}
	}

（2） 讲解格式，画内存图
17. 二位数组格式3的讲解及其内存图
（1） 二维数组格式3
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

	class Demo3_Array	{
		public static void main(String[] args)	{
		int[][] arr ={{1,2,3},{4,5},{6,7,8,9}}; //这是二维数组，每个大括号代表一个一维数组， 
		}	
	}

18. 二维数组练习1遍历
（1） 二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。

class Demo4_Array	{
	public static void main(String[] args)	{
		int[][] arr ={{1,2,3},{4,5},{6,7,8,9}}; //这是二维数组，每个大括号代表一个一维数组
		for(int i = 0;i < arr.length;i++)	{   //获取每个二维数组的一维数组
		for(int j = 0;j < arr[i].length ;j++)	{ 
			System.out.print (arr[i][j] + “ “);
		}
		System.out.println(); 
		}
	}
}

19. 二维数组的练习2求和
    需求：公司年销售求和
    某公司按照季度和月份统计的数据如下：单位（万元）
    第一季度：22，66，44
    第二季度：77，33，88
    第三季度：25，45，65
    第四季度：11，66，99

class Test	{
	public static void main (String[] args)	{
	int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
	int sum = 0;
	for(int i = 0; i < arr.length; i++)	{
		for(int j = 0;j < arr[i].length;j++)	{
			sum = sum + arr[i][j];
		}
	}
	System.out.println(sum);
	}
}

20. Java中的参数传递问题及图解
    （1） 基本数据类型的值传递，不改变原值，因为调用后会弹栈，局部变量随之消失
    （2） 引用数据类型的值传递，改变原值，因为即使方法弹栈，但是堆内存数组对象还在，可以通过地址继续访问
    （3） Java中到底是传值还是传址
    即是传值，也是传址，基本数据类型传递的值，引用数据类型传递的地址
    Java中也只有传值，因为地址值也是值（面试都说这种，因为是java之父提出的。

class Test	{
	public static void main (String[] args)	{
			int a = 10;
			int b = 20;
			System.out.println(“a:” + a + “,b:” + b);   //a = 10;b = 20
			change(a,b);
			System.out.println(“a:” + a + “,b:” + b);   //a = 10;b = 20,因为调用完change方法后，change方法弹栈，局部变量随机消失

			int[] arr = {1,2,3,4,5};
			change(arr);
			System.out.println(arr[1]);   //arr[1]=4，此处为引用数据类型的值传递
}

	public static void change (int a,int b)	{  			//a = 10;b = 20
			System.out.println(“a:” + a + “,b:” + b);		//a = 10;b = 20
				a = b;          //a = 20;
				b = a + b;     //b = 40;
			System.out.println(“a:” + a + “,b:” + b);   //a = 20;b = 40
		}
	public static void change (int[] arr)	{	//arr = {1,2,3,4,5};
			for(int x = 0;x < arr.length;x++)	{
				if(arr[x] % 2 == 0)	{
					arr[x] *= 2;    // 1，4，3，8，5
			}
		}