Java dingyi yige shuz JAVA定义一个数组判断年龄

6.JAVA基础（数组）

• 1.数组
• 2.数组定义格式
• 3.数组初始化

• 3.1 动态初始化
• 3.2 静态初始化

• 4.数组常见的2个异常
• 5.java中的内存分配
• 6.数组的遍历

1.数组

比如：班上有32个同学，如果我要统计所有同学的年龄，计算平均年龄，最高年龄等等
定义32个变量分别保存每个同学的年龄，然后再进行操作，这样会显得很麻烦
所有java就提供了数组，解决这种问题
数据就是用来存储多个变量（元素）的东西（容器）
变量的数据类型要一致
数组即可以存储基本数据类型也可以存储引用数据类型

2.数组定义格式

数组的定义格式：
1.数据类型[] 数组名; int[] a;
定义了一个int类型的数组a变量

2.数据类型 数组名[]; int b[];
定义了一个int类型的b数组变量

格式1和格式2的效果是一样的，没有什么区别，只是读法上有不同，推荐使用格式一，因为第一张其他语言也有使用

3.数组初始化

java中数组必须进行初始化，所谓初始化就是为了数组中数组元素分配内存空间，并为每个数组元素赋值

3.1 动态初始化

动态初始化：初始化时只只定数组长度，由系统为数组分配初始化值

格式：数组类型[] 数组名 = new 数据类型[数组长度]
数组长度其实就是数组中元素的个数
new:分配内存空间
通过数组名访问数据的格式：数组名[索引]

3.2 静态初始化

静态初始化：初始化时只定每个数组元素的初始值，由系统决定数组长度
格式：数据类型[] 数组名 = new 数组类型[]{元素1，元素2，…}
举例：int[] arr = new int[]{1,2,3}

解释：定义了一个int类型的数据，数组名是arr，这个数组可以存放3个int类型的值，值分别是1，2，3
简写int[] arr = {1,2,3};
一般使用静态初始化

4.数组常见的2个异常

5.java中的内存分配

Java程序再运行时，需要再内存中分配空间，为了提高运算效率，就对空间进行了不同区域的划分，每一篇区域都有特定的处理数据的方式和内存管理方式
1.栈：存储局部变量 栈内存 的数据使用完就释放（脱离了作用域的时候就释放）
局部变量：方法定义中或者方法申明上上的变量都成为局部变量

2.堆：存储new出来的东西 使用完毕就变成垃圾，会在垃圾回收器空闲的时候回收
每一个new出来的东西都有地址值
每个变量都有默认值
byte,short,int,long默认值0
float,double默认值：0.0
char默认值是’\u0000’
boolean默认值：false
引用类型 默认值：null
3.方法区：

4.本地方法区：和系统相关

5.寄存器：给cpu使用

总结：栈内存的两个引用指向同一个堆内存

6.数组的遍历

我们在很多时候，数组的元素不能看人去数 这个时候数据给我们提供了一个属性：length专门用来获取数组的长度
格式：数组名.length返回数组的长度
基础遍历：

for (int x = 0; x < arr.length; x++) {
			System.out.println(arr[x]);
		}

改进：

for (int x = 0; x < arr.length; x++) {
			if(x == arr.length-1){
				System.out.print(arr[x]);
			}else{
				System.out.print(arr[x]+",");
			}
		}

用方法改进：
/*
* 遍历数组的方法
*
* 参数列表：int[] arr
* 返回值类型：void
*/

public static void printArray(int[] arr) {
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x]);
			} else {
				System.out.print(arr[x] + ",");
			}
		}
		System.out.println();
	}

数组获取最大值
package com.yige.array;

/*

• 需求：数组获取最大值
• 
  
• 分析：
• a.定义一个数组，并对数组的元素进行静态初始化
• b.从数组中任意的找一个元素作为参照物（一般取第一个），默认他就是最大值
• c.然后遍历其他的元素，依次获取和参照物进行比较，如果大就是擂主 ，如果小就离开
• d.最后参照物保存的就是最大值
• */

public class ArrayTest2 {
	public static void main(String[] args) {
		// a.定义一个数组，并对数组的元素进行静态初始化
		int[] arr = { 12, 45, 78, 11, 78 };

		// b.从数组中任意的找一个元素作为参照物（一般取第一个），默认他就是最大值
		int max = arr[0];

		// c.然后遍历其他的元素，依次获取和参照物进行比较，如果大就是擂主 ，如果小就离开
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > max) {
				max = arr[x];
			}
		}

		System.out.println("max:" + max);
	}
}

数组元素逆序
package com.yige.array;

/*

• 需求：数组元素逆序
• 
  
• 分析：
• a.定义一个数组，并对数组的元素进行静态初始化
• b.把0索引和arr.length-1进行交换
• 把1索引和arr.length-2进行交换
• 到arr.length/2的时候就停止
• */

public class ArrayTest3 {
	public static void main(String[] args) {
		// a.定义一个数组，并对数组的元素进行静态初始化
		int[] arr = { 12, 45, 78, 11, 78 };
	
		System.out.println("逆序前：");
		printArray(arr);
		
		// int temp = arr[0];
		// arr[0] = arr[arr.length-1-0];
		// arr[arr.length-1] = temp;
		//
		// int temp1 = arr[1];
		// arr[1] = arr[arr.length-1-1];
		// arr[arr.length-1-1] = temp;
		
		
		reverse(arr);
		
		System.out.println("逆序后：");
		printArray(arr);
	}

/*
 * 数组逆序方法
 * 
 * 参数列表：int[] arr 
 * 返回值类型：void
 * */

public static void reverse(int[] arr){
		for(int x=0;x<arr.length/2;x++){
			int temp = arr[x];
			arr[x] = arr[arr.length-1-x];
			arr[arr.length-1-x] = temp;
		}
	}

/*
 * 遍历数组的方法
 * 
 * 参数列表：int[] arr 
 * 返回值类型：void
 */

public static void printArray(int[] arr) {
		for (int x = 0; x < arr.length; x++) {
			if (x == arr.length - 1) {
				System.out.print(arr[x]);
			} else {
				System.out.print(arr[x] + ",");
			}
		}
		System.out.println();
	}
}

数组元素查找
基本查找
package com.yige.array;

import java.util.Scanner;

/*

• 需求：数组元素查找（查找指定元素第一次在数组中出现索引）
• 基本查找：从头找到尾
• 
  
• 分析：
• a.定义一个数组，并对数组的元素进行静态初始化
• b.遍历数组，依次获取数组中每一个元素，和要找的数据进行比较
• 如果相等：就返回当前索引
• */

public class ArrayTest4 {
	public static void main(String[] args) {
		// a.定义一个数组，并对数组的元素进行静态初始化
		int[] arr = { 12, 45, 78, 11, 78 };

		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你要查找的数据：");
		int value = sc.nextInt();

		int index = -1;

		// b.遍历数组，依次获取数组中每一个元素，和要找的数据进行比较
		// for (int x = 0; x < arr.length; x++) {
		// if (arr[x] == value) {
		// index = x;
		// break;
		// }
		// }

		System.out.println("index:" + getIndex(arr,value));
	}

/*
 * 数组元素查找（查找指定元素第一次在数组中出现索引）
 * 
 * 参数列表：int[] arr,int value 
 * 返回值类型：int
 */

public static int getIndex(int[] arr, int value) {
		// 定义一个索引，如果找不到数据，我们一般直接返回一个负数
		int index = -1;
		
		for (int x = 0; x < arr.length; x++) {
			if (arr[x] == value) {
				index = x;
				break;
			}
		}
		
		return index;
	}
}

二分查找（折半查找）
package com.yige.array;

import java.util.Scanner;

/*

• 二分数组查找
• 
  
• 分析：
• a.定义最大索引，最小索引
• b.计算出中间索引 最大索引+最小索引/2
• c.拿中间值和要查找的值进行比较

相等：就返回当前中间索引

大于：左边找，max = mid-1

小于：右边找，min = mid+1

• 重写计算中间索引，回到b
• */

public class ArrayTest5 {
	public static void main(String[] args) {
		int[] arr = { 12, 45, 54, 65, 87 };

		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你要查找的数据：");
		int value = sc.nextInt();

		

		System.out.println("mid:" + getIndex(arr,value));
	}

/*
 * 二分数组查找
 * 
 * 参数列表：int[] arr,int value
 * 返回值类型：int
 * */

public static int getIndex(int[] arr,int value){
		// a.定义最大索引，最小索引
		int max = arr.length - 1;
		int min = 0;

		// b.计算出中间索引 最大索引+最小索引/2
		int mid = (max + min) / 2;

		while (arr[mid] != value) { // false
			if (arr[mid] > value) {
				max = mid - 1;
			} else if (arr[mid] < value) {
				min = mid + 1;
			}
			
			if(min>max){
				return -1;
			}

			mid = (max + min) / 2;
		}
		
		return mid;
	}
}