数组及数组操作

数组【重点】

1. 数组

1.1 生活中的数组

超市
	生活中非常常见的归纳总结数据的过程。

图书馆
	图书分类
		社科类 T
	图书会根据书架位置有一个独立编码
	一本书可能出现多本
	
	<<NIO与Socket编程技术指南>> 10本
	T-1-20-01 ~ T-1-20-10
	1. 可以统一管理
	2. 又可以做到独立操作。
	
总结:
	1. 该图书会在图书馆中占据一个连续的存储空间
	2. 该图书有一个统一的名称<<NIO与Socket编程技术指南>> ==> T-1-20
	3. 每一本图书都有一个独立编号T-1-20-01 ~ T-1-20-10	

1.2 代码中对于数组的期望

	实际开发场景中，一定会出现大量相同数据的使用情况。如果按照单一变量数据方式处理，会导致代码中出现以下问题；
	1. 代码过程臃肿
	2. 代码阅读性极差
	3. 代码操作性，维护性极差

可以模仿图书馆管理图书的方式来处理数据操作过程:
	1. 连续存储
	2. 统一名称
	3. 独立编号

1.3 Java中定义数组的格式【重点】

数据类型[] 数组名 = new 数据类型[容量];

赋值号左侧:
	数据类型:
		明确告知编译器，当前数组可以保存支持的数据类型到底是哪一个，并且有且只能
		是哪一个。保证【数据类型一致化】
	[]:
		1. 明确告知编译器，这里定义的是一个数组类型
		2. 告知编译器，当前数组名是一个【引用数据类型】的变量
	数组名:
		1. 是当前数组的操作使用的，重要名称
		2. 数组名是一个【引用数据类型】变量

赋值号右侧:
	new:
		new关键字在内存中申请内存【堆区】数据空间，并且将申请的内存空间全部擦除干
		净。
		堆区：相当于一个生活中的仓库，new关键字用于申请仓库中的空间。当前申请的仓
		库空间需要清理干净
		
	数据类型:
		前后呼应，要求和赋值号左侧完全一致，明确告知编译器，当前能够使用的数据类
		型到底是哪一个。保证【数据类型一致化】
	
	[容量]:
		当前数组可以保存指定数据类型的容量个数，容量一旦确定无法更改~~~   

1.4 Java中定义数组演示

/*
Java中定义数组的形式
*/
class Demo2 {
	public static void main(String[] args) {
		/*
		在代码中定义了一个数组，
		数组的数据类型为int
		数组名 arr
		数组容量 10，可以保存10个int类型数组
			数组容量有且只允许在int类型范围以内，不允许负数
		当前数组占用内存空间 40+
		*/
		int[] arr = new int[10];
	}
}

1.5 数组使用和下标问题

1. 数组操作是依赖于数组名进行
	数组名是代表整个数组
2. 数组操作需要使用下标，下标范围是0 ~ 数组容量 - 1
	int[] arr = new int[10];
	有效下标范围:
		0 ~ 9
		【原则】下标没有负数，负数可以用于操作非法情况
		如果操作过程中下标位置超出范围 
		ArrayIndexOutOfBoundException 数组下标越界异常

数组操作【重点】

1. 数组分析

1.1 数组内存分析

1.1.1 生活案例引入

洗浴中心
	引用数据类型 ==> 洗浴中心的名片
		洗浴中心的名片有该洗浴中心的地址
	
	开着凯迪拉克 XT4 根据地址导航到目的地
		寻址 ==> 寻找当前地址
	
	我在门口等着你，给你一个小惊喜(手牌)
		手牌有对应柜子的编号，可以存放物品
		柜子就是数组的数据空间，手牌是数组中的下标位置

1.1.2 数组内存分析图【重点】

1.2 数组转移问题

class Demo1 {
	public static void main(String[] args) {
		// 定义两个int类型数组，数组容量都为10
		int[] arr1 = new int[10];
		int[] arr2 = new int[10];
		
		arr1[0] = 10;
		arr2[5] = 200;
		
		System.out.println(arr1[0]);
		System.out.println(arr2[5]);
		
		arr1 = arr2;
		
		arr1[5] = 500;
		arr2[0] = 100;

		System.out.println(arr1[0]); // 100 [100] 10  10
		System.out.println(arr2[5]); // 200 [500] 500 200
	}
}

2. 数组操作

2.1 数组和for循环不得不说的故事

数组属性:
	数组名.length 获取当前数组的容量/长度

for循环格式
	for (循环条件初始化; 循环条件判断; 循环条件变更) {
		// 循环体
	}

例如:
	int[] arr = new int[10];
	for (int i = 0; i < arr.length; i++) {
		
	}

/*
数组和for循环完成赋值和取值问题
*/
class Demo2 {
	public static void main(String[] args) {
		// 定义了一个int类型数组，容量为10
		int[] arr = new int[10];
		
		// 使用for循环对数组中的每一个元素进行赋值操作
		// arr.length . ==> 的 数组arr的容量
		for (int i = 0; i < arr.length; i++) {
			// 赋值数组中指定下标的元素，i从0开始到9结束，对应数组下标
			arr[i] = i + 1;
		}
		
		// 取值展示数据
		for (int i = 0; i < arr.length; i++) {
			System.out.println("arr[" + i + "] = " + arr[i]);
		}
	}
}

2.2 数组作为方法参数的封装

模版:
	public static void main(String[] args) {
	
	}
格式:
	public static 返回值类型 方法名(数据类型[] 参数数组名) {
	
	}

/*
数组和for循环完成赋值和取值问题
*/
class Demo3 {
	public static void main(String[] args) {
		// 定义了一个int类型数组，容量为10
		int[] arr = new int[10];
		
		// 如果一个方法所需参数为数组类型，这里传入对应数组的数组名即可
		assignIntArray(arr);
		
		printIntArray(arr);
	}
	
	/**
	* 赋值用户指定的int类型数组
	*
	* @param arr 要求用户传入的int类型数组
	*/
	public static void assignIntArray(int[] arr) {
		// 使用for循环对数组中的每一个元素进行赋值操作
		// arr.length . ==> 的 数组arr的容量
		for (int i = 0; i < arr.length; i++) {
			// 赋值数组中指定下标的元素，i从0开始到9结束，对应数组下标
			arr[i] = 2 * i;
		}
	}
	
	/**
	* 展示用户提供的int类型数组
	*
	* @param arr 用户提供的int类型数组
	*/
	public static void printIntArray(int[] arr) {
		// 取值展示数据
		for (int i = 0; i < arr.length; i++) {
			System.out.println("arr[" + i + "] = " + arr[i]);
		}
	}
}

2.3 逆序数组中的数据

数组原型:
	int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	==>
	{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

/**
* 逆序int类型数组中的所有元素
*
* @param arr 用户指定的int类型数组
*/
public static void reverse(int[] arr) {
    // i < arr.length / 2  依次1,10；2，9 。。。调换顺序
	for (int i = 0; i < arr.length / 2; i++) {
		// arr[i] <==> arr[arr.length - 1 - i];
		int temp = arr[i];
		arr[i] = arr[arr.length - 1 - i];
		arr[arr.length - 1 - i] = temp;
	}
}

2.4 找出数组中最大值下标位置

数组原型:
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
	max index = 4

/*
2.4 找出数组中最大值下标位置
数组原型:
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
	max index = 4
*/
class Demo5 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 19, 2, 4, 16, 28, 1};
		
		int maxIndex = findMaxIndex(arr);
		
		System.out.println("maxIndex : " + maxIndex);
	}
	
	/**
	* 找出指定int类型数组中最大值下标位置
	*
	* @param arr 用户指定的int类型数组
	* @return 返回值是最大值下标所在位置
	*/
	public static int findMaxIndex(int[] arr) {
		// 假设思想
		// 在当前数组中下标为0的元素是最大值
		int maxIndex = 0;
		
		// 利用循环遍历整个数组，如果发现有元素大于当前maxIndex保存
		// 下标对应元素，记录当前下标
		for (int i = 1; i < arr.length; i++) {
			if (arr[maxIndex] < arr[i]) {
				maxIndex = i;
			}
		}
		
		return maxIndex;
	}
}

2.5 找出数组中最小值下标位置

数组原型:
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
	max index = 0

/*
2.5 找出数组中最小值下标位置
数组原型:
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 1};
	max index = 0
*/
class Demo5 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 19, 2, 4, 16, 28, 1};
		
		int minIndex = findMinIndex(arr);
		
		System.out.println("minIndex : " + minIndex);
	}
	
	/**
	* 找出指定int类型数组中最小值下标位置
	*
	* @param arr 用户指定的int类型数组
	* @return 返回值是最小值下标所在位置
	*/
	public static int findMinIndex(int[] arr) {
		// 假设思想
		// 在当前数组中下标为0的元素是最大值
		int minIndex = 0;
		
		// 利用循环遍历整个数组，如果发现有元素小于于当前minIndex保存
		// 下标对应元素，记录当前下标
		for (int i = 1; i < arr.length; i++) {
			if (arr[minIndex] > arr[i]) {
				minIndex = i;
			}
		}
		
		return minIndex;
	}
}

2.6 找出指定元素在数组中的下标位置

数组原型:
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}
	找出元素 5 对应下标为 2
	找出元素 10 对应下标为 9
	找出元素 20 对应下标为 -1 表示没有找到

/*
2.6 找出指定元素在数组中的下标位置
数组原型:
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}
	找出元素 5 对应下标为 2
	找出元素 10 对应下标为 9
	找出元素 20 对应下标为 -1 表示没有找到
*/
class Demo6 {
	public static void main(String[] args) {
		int num = 9;
		int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
		
		int index = indexOf(arr, num);
		
		if (-1 == index) {
			System.out.println("指定数据未找到");
		} else {
			System.out.println("目标元素所在下标位置 : " + index);
		}
	}
	
	/**
	* 在指定数组中，找出指定元素的下标位置
	* 
	* @param arr 指定查询数据的目标int类型数组
	* @param num 指定需要查询的数据
	* @return 找到对应元素返回值大于等于0，否则 -1
	*/
	public static int indexOf(int[] arr, int num) {
		/* 
		需要获取下标位置
		存在未找到情况！！！
		这里index初始化为-1 更方便的获取对应的下标信息
		 */
		int index = -1; // -1 
		
		// 利用循环遍历整个数组，比对数据
		for (int i = 0; i < arr.length; i++) {
			// 如果发现存在元素和当前指定元素一致。保存下标【终止循环】
			if (num == arr[i]) {
				index = i;
				// 已经找到目标元素，需要终止循环，使用break关键字
				break;
			}
		} 
		
		return index;
	}
}

2.7 在指定数组中的指定下标位置插入元素【难点】

存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
	要求
		1. 0是无效元素，仅占位使用
		2. 当前数组中【有效元素】个数为 9
	需求
		在该数组中的指定下标位置放入指定元素

/*
存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
	要求
		1. 0是无效元素，仅占位使用
		2. 当前数组中【有效元素】个数为 9
	需求
		在该数组中的指定下标位置放入指定元素
*/
class Demo7 {
	public static void main(String[] args) {
		int index = 5;
		int insert = 20;
		int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		
		boolean result = add(arr, index, insert);
		
		if (result) {
			printIntArray(arr);
		} 
	}
	
	/*
	方法分析:
		public static:
			不要问，固定格式
		返回值:
			boolean 类型 如果方法运行成功，返回true，失败返回false
			失败是因为用户提供的数据不合法！！！
		方法名:
			add 添加
		形式参数列表:
			int[] arr 指定操作数据
			int index 指定下标位置
			int insert 插入数据
	
	方法声明:
		public static boolean add(int[] arr, int index, int insert)
	*/
	/**
	* 在数组中指定下标位置，添加用户指定的元素
	*
	* @param arr    指定操作数据
	* @param index  指定下标位置
	* @param insert 插入数据
	* @return 方法运行成功返回true，否则返回false
	*/
	public static boolean add(int[] arr, int index, int insert) {
		// 用户输入参数合法性判断
		if (index < 0 || index > arr.length - 1) {
			System.out.println("Illegal Index 非法下标！");
			// return终止方法运行，同时false表示当前方法运行失败
			return false;
		}
		
		/*
		移动数组中的内容，腾出插入数据的下标位置
		*/
		for (int i = arr.length - 1; i > index; i--) {
			arr[i] = arr[i - 1];
		}
		
		arr[index] = insert;
		
		// 返回true表示方法运行成功
		return true;
	}
	
	
	/**
	* 展示用户提供的int类型数组
	*
	* @param arr 用户提供的int类型数组
	*/
	public static void printIntArray(int[] arr) {
		// 取值展示数据
		for (int i = 0; i < arr.length; i++) {
			System.out.println("arr[" + i + "] = " + arr[i]);
		}
	}
}

2.8 删除数组中的指定下标的元素【难点】

存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
	要求:
		1. 0是无效元素，仅占位使用
	需求:
		在当前数组中删除指定下标的元素
	例如:
		指定下标5
		结果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0} 
		0占位！！！

class Demo8 {
	public static void main(String[] args) {
		int index = 1;
		int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
		
		boolean ret = remove(arr, index);
		
		if (ret) {
			printIntArray(arr);
		}
	}
	
	/**
	* 删除数组中指定下标的元素
	* 
	* @param arr   删除数据的目标数组
	* @param index 指定删除的下标位置
	* @return 成功返回true，否则返回false
	*/
	public static boolean remove(int[] arr, int index) {
		if (index < 0 || index > arr.length - 1) {
			System.out.println("ArrayIndexOutOfBoundsException 数组下标越界");
			return false;
		}
		
		for (int i = index; i < arr.length - 1; i++) {
			arr[i] = arr[i + 1];
		}
		
		arr[arr.length - 1] = 0;
		
		return true;
	}
	
	/**
	* 展示用户提供的int类型数组
	*
	* @param arr 用户提供的int类型数组
	*/
	public static void printIntArray(int[] arr) {
		// 取值展示数据
		for (int i = 0; i < arr.length; i++) {
			System.out.prin2tln("arr[" + i + "] = " + arr[i]);
		}
	}
}

2.9 找出指定元素在指定数组中所有下标位置 【难点】

/*
要求：
	a. 不允许在方法内打印展示
	b. 考虑多个数据情况
	c. 需要在方法外获取到下标数据信息
	d. 不允许使用数组作为返回值
*/

2.10 排序算法推演

int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

第一题:
	找出数组中最大值，和下标为0的元素交换位置
	{10, 3, 5, 7, 9, 2, 4, 6, 8, 1}
第二题:
	找出数组中剩余数据最大值(当前数组中下标为0的元素是最大值)，和下标为1的元素交换位置
	{10, 9, 5, 7, 3, 2, 4, 6, 8, 1}
第三题:
	找出数组中剩余数据最大值(当前数组中下标为0, 1的元素是最大值)，和下标为2的元素交换位置
	{10, 9, 8, 7, 3, 2, 4, 6, 5, 1}

核心思路
	1. 找
	2. 换

3.二维数组

二维数组可以看做数组的数组：二维数组就是一个特殊的以为数组，其每一个元素都是一维数组

int array[][] = new int[2][3];
这个二维数组array可以看做一个二行三列的数组
    
    int a[][] = {{1,2}, {2,3}}

public class Test {

    public static void main(String[] args) {

     int a[][] = {{1,2}, {2,3}};


        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.println(a[i][j]);
            }
        }
    }
}
/*
输出结果为：
1
2
2
3
*/