day4数组

数组：

存储同一类型多个元素的容器

格式：
1，数组类型[ ]数组名              int [ ] arr(推荐使用)
2，数据类型 数组名[ ]             int arr [ ]

初始化：

数组初始化：
 		A:所谓的初始化，其实就是为数组开辟内存空间，并为数组中的每个元素赋予初始值。
 		B:如何进行初始化呢?我们有两种方式对数组进行初始化
 			a:动态初始化	只给出长度，由系统给出初始化值
 			b:静态初始化	给出初始化值，由系统决定长度

public class arry {
	public static void main(String[] args) {
		int[] arr = new int[3];
	  
		System.out.println(arr);//打印的是地址
		System.out.println(arr[1]);//获取数组的值
		 * 左边：
		 * 		int:说明的是数组中的元素类型是int类型
		 * 		[]:说明这是一个数组
		 * 		arr:这是数组的名称
		 * 右边：
		 * 		new:为数组申请分配内存空间。
		 * 		int:说明的是数组中的元素类型是int类型
		 * 		[]:说明这是一个数组
		 * 		3:数组长度，其实就是数组中的元素个数
		 */
	}
}

java的内存分配：

栈：（局部变量）

	存储的是局部变量  （相当于）
	局部变量其实就是定义在方法中的变量
	使用完毕，立刻回收

堆：new出来的东西，实体，对象

	a，每一个对象都有地址值
	b，每一个对象的数据都有初始值
	     byte  short int long   0
	     float  double     0.0
	     char   ‘\u0000’
	     boolean false
	     引用类型    null
	c，数据使用完毕后，会在垃圾站回收站空闲的时候回收

public class arry {
	public static void main(String[] args) {
		int[] arr=new int[3];
		//赋值
		arr[0]=100;
		arr[2]=200;
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

数组的内存图：

两个数组指向同一个地址

public class arry {
	public static void main(String[] args) {
		int[] arr1=new int[3];		
		arr1[0]=100;
		arr1[1]=200;
		arr1[2]=300;		
		int[] arr2=arr1;//将arr1的地址值赋值给arr2
		System.out.println(arr1);
		System.out.println(arr2);
				
		//此时arr2的数值和arr1的数值相同，指向同一个地址
		System.out.println(arr2[1]);
				
		arr2[1]=111;		
		//两个数组指向同一个地址，任何一个数组对堆内存修改，另一个也跟着修改
		System.out.println(arr1[1]);
		System.out.println(arr2[1]);
		
	}
}

图解

静态初始化

•静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

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

数组的常见问题：

public class arry {
	public static void main(String[] args) {
		int[] arr={1,2,3};
	
		//数组索引越界了
		System.out.println(arr[3]);
		//java.lang.ArrayIndexOutOfBoundsException
				
		arr =null;		
		//引用数据类型：
		//常量：null表示不再指向对内存的数据
		System.out.println(arr[1]);
		//java.lang.NullPointerException
	}
}

数组的遍历

public class arry {
	public static void main(String[] args) {
		int[] arr={11,22,33};		
		for(int a=0;a<arr.length;a++){
			System.out.println(arr[a]);
		}	
	}
}

数组求最值

public class arry {
	public static void main(String[] args) {
		//定义一个数组
		int[] arr={11,22,33};		
		//定义一个参照物
		int max =arr[0];
		//从第二个开始遍历
		for (int a=1;a<arr.length;a++){
			if(arr[a]>max){
				max=arr[a];
			}
		}
		System.out.println(max);
	}
}

练习1

public class arry {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] arr = new int[6];
		for (int x = 0; x < arr.length; x++) {
			System.out.println("请第" + (x + 1) + "个评委打分");
			int score = sc.nextInt();
			arr[x] = score;
		}
		for (int y = 0; y < arr.length; y++) {
			System.out.print(arr[y] + " ");
		}
		System.out.println();

		int max = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		System.out.println("最高分：" + max);

		int min = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] < max) {
				min = arr[i];
			}
		}
		System.out.println("最低分：" + min);

		int sum = 0;
		for (int x = 0; x < arr.length; x++) {
			sum += arr[x];
		}
		System.out.println("总成绩：" + sum);

		int avg = (sum - max - min) / (arr.length - 2);
		System.out.println("平均分：" + avg);
	}
}

不死兔子

public class arry {
	public static void main(String[] args) {
		int[] arr=new int[20];
		arr[0]=1;
		arr[1]=1;
		
		for (int x=2;x<arr.length;x++){
			arr[x]=arr[x-1]+arr[x-2];
		}
		System.out.println(arr[arr.length-1]);
	}
}