Java第二周学习

1. 数组

1.1 定义数组格式

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

 int[] arr = new int[10];

赋值左侧

数据类型:
告知编译器，当前数组中能够保存的数据类型到底是什么？并且在确定数据类型之后，整个数组中保存的数据类型无法修改！！！
[]:

告知编译器这里定义的是一个数组类型数据。
明确告知编译器，数组名是一个【引用数据类型】

数组名:

操作数据非常重要的数据！！！
数组名是一个【引用数据类型】

小拓展: int(*) (void *, void *)

赋值号右侧：

new:

	申请【XX】内存空间，并且清空整个内存空间中所有二进制位，所有的二进制

	位都是0

数据类型:

	前后呼应，告知编译器这里支持存储的数据类型到底是什么？

[容量]:

	容量==> Capacity

	告知编译器，当前数组中能够存放的对应数据类型的数据，最大存储多少

	个！！

	【注意】

		一旦确定容量，针对于当前数组，后期容量无法修改

1.2 数组的下标【重点】

规定
数组中的下标是从0开始，到数组的容量 - 1

例如:
数组容量为10
有效下标范围: 0 ~ 9
超出有效下标范围，都是无效下标，后期考虑数组处理异常问题，负数使用问题

操作会出现的问题:
1. 数组下标越界
ArrayIndexOutOfBoundsException

1.3 数组内存分析图

【补充知识点引用数据类型】
开发中引用数据类型
用于保存其他内存空间的首地址，保存地址之后，CPU可以通过对应的引用数据类型，得到对应的地址，从而访问地址对应内存空间。
引用数据类型包括字符串，数组，对象。就这三个！

获取数组容量的方式
数组名.length 属性
当前数组的属性length是要占用一定的数组空间的，属于数组中的内容，这就是为什么数组中占用的空间要比存储数据计算空间略大一些。

1.4 数组地址转移问题

class Demo3 {
	public static void main(String[] args) {
		int[] arr1 = new int[10];
		int[] arr2 = new int[10];

		arr1[5] = 100;
		arr2[5] = 500;
		
		System.out.println(arr1[5]);
		System.out.println(arr2[5]);
		
		arr1 = arr2;
		arr1[5] = 2000;
		
		System.out.println(arr1[5]);
		System.out.println(arr2[5]);
	}
}

数组地址转移示意图

1.5 数组在方法中的使用

class Demo4 {
	public static void main(String[] args) {
		int[] array = new int[10];
		
		// 调用赋值数组中元素的方法
		// 调用参数是一个数组类型的方法，需要传入的内容是数组名
		assignIntArray(array);
		printIntArray(array);
	}
	
	/*
	需求：
		赋值一个int类型的数组
	方法分析：
		public static 固定格式 不要问
		返回值类型：
			void 无返回值
		方法名:
			assignIntArray 见名知意，动宾结构，小驼峰命名法
		形式参数列表:
			这里需要的是一个int类型的数组
			(int[] arr)
	方法声明：
		public static void assignIntArray(int[] arr)
	*/
	/**
	* 赋值一个指定的int类型数组
	*
	* @param arr 这里需要的参数是一个int类型数组
	*/
	public static void assignIntArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i + 1;
		}
	}
	
	/*
	需求
		展示一个int类型数组中保存的数据
	方法分析：
		public static： 不要问
		返回值类型:
			void
		方法名：
			printIntArray
		形式参数列表：
			这里需要展示的是一个int类型数组
			(int[] arr)
	方法声明:
		public static void printIntArray(int[] arr)
	*/
	/**
	* 展示一个int类型数组中保存的数据
	*
	* @param arr 这里需要的是一个int类型数组
	*/
	public static void printIntArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println("array[" + i + "]=" + arr[i]);
		}
	}
}

1.6 数组算法

1.6.1 完成一个数组逆序过程

/*
静态数组
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
	逆序完成
		{10, 8, 6, 4, 2, 9, 7, 5, 3, 1};
方法的分析
	public static 不要问
	返回值类型:
		void 不需要返回值
	方法名:
		逆序 reverse
	形式参数列表:
		int[] arr
方法声明:
	public static void reverse(int[] arr)
*/

/**
* 完成对于int类型数组的逆序过程
*
* @param arr int类型数组
*/
public static void reverse(int[] arr) {
    int temp = 0;
    for (int i = 0; i < arr.length / 2; i++) {
        /*
        arr[0] = arr[9]
        arr[1] = arr[8]
        arr[2] = arr[7]
        arr[3] = arr[6]
        arr[4] = arr[5]
        */
        temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
}

1.6.2 找出数组中最大值所在下标位置

class ArrayMethod2 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 19, 2, 4, 19, 8, 10};
		
 		int index = maxIndexOf(arr);
		System.out.println("index:" + index);
	}
	
	/*
	需求
		从int类型数组中找出对应的最大值下标位置
	方法分析:
		public static 不要问
		返回值类型：
			数组的下标数据类型是int类型
			int
		方法名:
			maxIndexOf
		形式参数列表：
			(int[] arr)
	方法声明：
		public static int maxIndexOf(int[] arr)
	*/

	/**
	* 返回指定int类型数组中最大值的下标位置
	*
	* @param arr int类型数组
	* @return 返回值是最大值所在的下标位置
	*/
	public static int maxIndexOf(int[] arr) {
		// 假定下标为0的元素是数组中最大值。
		int maxIndex = 0;
		
		// 因为循环过程中，没有必要假定的下标为0的元素和自己比较
		// 循环变量从1开始
		for (int i = 1; i < arr.length; i++) {
			/*
			如果发现maxIndex保存的下标对应元素，是小于i的
			保存对应的i值
			*/
			if (arr[maxIndex] < arr[i]) {
				maxIndex = i;
			}
		}
		
		return maxIndex;
	}
}

1.6.3 找出数组中指定元素所在的第一次出现下标位置

class ArrayMethod3 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
		
		int index = indexOf(arr, 1);
		if (index >= 0) {
			System.out.println("index : " + index);
		} else {
			System.out.println("Not Found!");
		}
		
	}
	/*
	需求:
		找出数组中指定元素出现的第一次下标位置
		1. 第一次出现的问题
		2. 多个元素问题
		3. 有可能不存在指定元素。
	方法分析:
		public static 不要问
		返回值类型:
			int 因为需要返回下标
			考虑在int范围以内，使用一个明确和正确数据有对立
			关系的数据作为【错误标记】
			找到对应数据 0 ~ array.length -1 
			-1 是一个明确的非法下标
		
		方法名：
			indexOf 找出对应元素所在下标位置
		形式参数列表:
			首先是一个int类型数组
			查询的数据也是int类型
			(int[] arr, int find)
	方法声明：
		public static int indexOf(int[] arr, int find)
	*/
	/**
	* 找出指定数组中，指定元素的下标位置，通过返回值返回
	*
	* @param arr 指定的int类型源数据数组
	* @param find 指定需要查询的数据
	* @return 返回值大于等于0，表示找到对应的数据，否则返回-1
	*/
	public static int indexOf(int[] arr, int find) {
		// 首先假设对应查询的数据是不存在的！！！
		int index = -1;
		
		// 利用循环，从下标为0的元素开始到最大下标，比对是否存在find
		for (int i = 0; i < arr.length; i++) {
			// 发现指定find元素和下标为i的元素一致
			if (find == arr[i]) {
				// 使用index保留对应的下标i
				index = i;
				// 终止循环！！！
				break;
			}
		}
		
		return index;
	}
}

1.6.4 获取数组中指定下标的元素

class ArrayMethod4 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
		
		System.out.println(get(arr, 20));
	}
	
	/*
	需求
		找出指定下标的元素
	方法分析：
		public static 不要问
		返回值类型：
			数组为int类型，这里返回值也是int类型
		方法名:
			get
		形式参数列表
			指定的数组 int[] arr
			指定的下标 int index
			0 ~ arr.length - 1
	方法声明：
		public static int get(int[] arr, int index)
	*/
	/**
	* 找出数组中指定下标的元素
	*
	* @param arr 指定的int类型数组  
	* @param int 指定查询的下标位置
	* @return 返回对应下标位置的元素
	*/
	public static int get(int[] arr, int index) {
		// 用户指定的index不能超出有效下标范围
		if (index < 0 || index > arr.length - 1) {
			/*
			返回任何的数据类型都不合适，可以考虑终止方法，
			并且告知用户错误是什么
			后期课程中可以使用到异常处理
			【用户输入参数合法性判断】
			*/
			System.out.println("Input Parameter is Invalid!");
			// 当前方法退出！！！
			System.exit(0);
		}
		
		return arr[index];
	}
	
}

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

public class Demo1 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 9, 0, 4, 6, 8, 10};
		
		// Ctrl + 1  Assign statement to new local variable
		int min = minIndexOf(arr);
		System.out.println("min index : " + min);
	}
	
	/*
	 * 1.1 找出数组中最小值的下标位置
	 * 
	 * 方法分析：
	 * 		public static 不要问
	 * 		返回值类型:
	 * 			这里需要返回数据是数组的下标
	 * 			int类型
	 *		方法名：
	 *			minIndexOf
	 *		形式参数列表：
	 *			这里需要一个int类型数组
	 *			(int[] arr)
	 * 方法声明:
	 * 		public static int minIndexOf(int[] arr)
	 */
	
	/**
	 * 当前方法是找出指定int类型数组中最小值所在的下标位置
	 * 
	 * @param arr int类型数组
	 * @return 最小值所在的下标位置
	 */
	public static int minIndexOf(int[] arr) {
		// 假设最小值下标位置是下标为0的元素
		int min = 0;
		
		for (int i = 1; i < arr.length; i++) {
			if (arr[min] > arr[i]) {
				min = i;
			}
		}
		
		return min;
	}
}

1.6.6 找出数组中指定元素的最后一次出现的下标位置

public class Demo2 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
		
		int index = lastIndexOf(arr, 7);
		
		System.out.println("last Index Of : " + index);
	}
	
	/*
	 * 1.2 找出数组中指定元素的最后一次出现的下标位置
	 * 方法分析：
	 * 		public static 不要问
	 * 		返回值类型：
	 * 			int 返回值是一个下标
	 * 		方法名：
	 * 			indexOf 第一次出现的位置
	 * 			lastIndexOf 最后一次出现的位置
	 * 		形式参数列表:
	 * 			1. 源数据数组，int类型
	 * 			2. 查询的指定元素 int类型
	 * 			(int[] arr, int find)
	 * 方法声明：
	 * 		public static int lastIndexOf(int[] arr, int find)
	 */
	/**
	 * 找出数组中指定元素最后一次出现的位置
	 * 
	 * @param arr 指定的int类型源数据数组
	 * @param find 指定需要查询的数据
	 * @return 返回值大于等于0表示找到数据，否则返回-1
	 */
	public static int lastIndexOf(int[] arr, int find) {
		// 假设我们找不到对应的数据
		int index = -1;
		
		for (int i = arr.length - 1; i >= 0; i--) {
			// 找到对应元素，保存index，终止循环
			if (find == arr[i]) {
				index = i;
				break;
			}
		}
		
		return index;
	}
}

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

/*
要求：
	a. 不允许在方法内打印展示
	b. 考虑多个数据情况
	c. 需要在方法外获取到下标数据信息
	d. 不允许使用数组作为返回值
【重点】
	1. 尾插法思想，计数器同时也是下一次存放数据的位置
	2. 数组作为方法参数之后，是可以近似数据传导
*/
/**
 * 【重点】
 * 
 * @author Anonymous
 */
public class Demo3 {
	public static void main(String[] args) {
		int[] arr = {5, 3, 5, 7, 5, 1, 3, 5, 7, 9};
		int[] indexArr = new int[arr.length];
		
		int count = allIndexOf(arr, indexArr, 5);
		
		// count是查询到的指定元素个数，同时可以利用与循环中，找到对应的元素
		for (int i = 0; i < count; i++) {
			System.out.println(indexArr[i]);
		}
		
	}
	
	/*
	 * 1.3. 找出指定元素在指定数组中所有下标位置 【难点】
	 * 要求：
	 * 		a. 不允许在方法内打印展示
	 * 		b. 考虑多个数据情况
	 * 		c. 需要在方法外获取到下标数据信息
	 * 		d. 不允许使用数组作为返回值
	 * 方法分析:
	 * 		public static 不要问
	 * 		返回值类型:
	 * 			int 返回找到的指定元素个数
	 * 			void 不行！！！少用黑盒方法！！！
	 * 			boolean true false 局限性比较大
	 * 		方法名:
	 * 			allIndexOf tips:感谢雄飞同学的友情提示
	 * 			找出所有指定元素的下标位置
	 * 		形式参数列表:
	 * 			1. 查询数据的源数据数组 int[] arr
	 * 			2. 指定查询的元素  int find
	 * 			3. 和源数据数组容量一致的int类型数组，保存对应的下标位置
	 * 			(int[] arr, int[] indexArr, int find)
	 * 问题：
	 * 		1. 查询数据可能是多个！！！
	 * 		2. 数组不能作为返回值！！！
	 * 		3. 不允许打印！！！
	 * 		4. 外部获取！！！
	 * 思考:
	 * 		1. 保存查询数据的下标位置一定会使用到数组
	 * 		2. 保存下标的数组数据类型是int类型
	 * 解决方案:
	 * 		通过方法为参数形式传入一个数组，int类型，保存找到的下标位置
	 * 思考:
	 * 		保存下标的数组容量如果考虑
	 * 解决方案:
	 * 		哪怕源数据数组中所有数据都是指定的元素，最大容量也就是
	 * 		和源数据数组的容量一致【判断的地方！！！】
	 * 
	 * 问题:
	 * 		有没有可能性下标为0的元素就是目标元素???
	 * 		0是有效下标范围
	 * 
	 * 		new创建一个新的数组，int类型数组中，所有的元素初始值都是0
	 * 		任何判断0是有效下标还是无效数据???
	 * 需求:
	 * 		这里需要一个数据，告知我找到数据到底有多少个
	 * 返回值:
	 * 		找到的指定元素的个数，如果没有找到，返回0 
	 * 
	 * 方法声明:
	 * 		public static int allIndexOf(int[] arr, int[] indexArr, int find)
	 *
	 */
	/**
	 * 找到指定源数据数组中所有指定元素所在的下标位置，保存到indexArr中，并且返回值
	 * 是找到的元素个数
	 * 
	 * @param arr 源数据数组，int类型
	 * @param indexArr 找到的下标位置存储数组，要求该数组的容量不得小于源数据容量
	 * @param find 需要查询的指定数据
	 * @return 返回值大于0，找到的数据个数，没有找到返回0
	 */
	public static int allIndexOf(int[] arr, int[] indexArr, int find) {
		// 参数合法性判断
		// 如果存储下标的数组长度小于原数组长度，有可能存储不完数据，
		// 这里就要提醒用户给的数组长度不对
		if (arr.length > indexArr.length) {
			System.out.println("Input Parameter is Invalid!");
			// 参数不合法，没有找到数据
			return 0;
		}
		
		/*
		 * 定义一个变量，
		 * 		1. 计数器，记录找到的元素个数
		 * 		2. 尾插法当中下一次存放元素的位置
		 */
		int count = 0;
		
		// 利用for循环遍历整个源数据arr数组
		for (int i = 0; i < arr.length; i++) {
			// 找到了对应的元素，需要保存下标i
			if (find == arr[i]) {
				// 保存到indexArr数组中
				// 需要使用尾插法！！！保存下一次存放数据的位置
				indexArr[count] = i; 
				// 计数器 += 1 
				count += 1;
			}
		}
		
		return count;
	}
}

1.6.8 在指定位置插入指定元素【难点】

/*
存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
	要求
		1. 0是无效元素，仅占位使用
		2. 当前数组中【有效元素】个数为9
	需求
		在该数组中的指定下标位置放入指定元素
【重点】
	1. 空数据，无效数据思想
	2. 数据的移动过程，粗加工，细打磨过程
	3. 时间消耗问题
*/

public class Demo4 {
	public static void main(String[] args) {
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		
		add(array, 9, 20);
		
		System.out.println(Arrays.toString(array));
	}
	
	/*
	1.4 在指定位置插入指定元素【难点】
	存在一个数组，数组中的元素为
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		要求
			1. 0是无效元素，仅占位使用 ==> null
			2. 当前数组中【有效元素】个数为9
		需求
			在该数组中的指定下标位置放入指定元素
	推演过程:
		    在数组下标为5的位置插入元素，从下标5开始
		之后的元素整体向右移动
		    arr[9] = arr[8];
		    arr[8] = arr[7];
		    arr[7] = arr[6];
		    arr[6] = arr[5];
		    arr[5] = 20;
		指定下标为5的位置添加元素，数组中的元素整体
		向后移动的4次
	
	方法分析：
		public static 不要问
		返回值类型:
			void 可用，但是不建议
			boolean 可以 true false 选择boolean类型
			int 可用 返回值的含义约束较为麻烦
		方法名:
			add 添加操作
		形式参数列表：
			1. 需要插入数据的数组
			2. 指定插入数据的下标位置
			3. 指定插入的数据
			(int[] arr, int index, int insert);
	方法声明：
		public static boolean add(int[] arr, int index, int insert);
		
	 */
	/**
	 * 在指定的数组中，指定位置插入指定元素
	 * 
	 * @param arr 指定的int类型数组
	 * @param index 指定的下标位置，必须在合理的区间范围以内
	 * @param insert 指定插入的元素，int类型
	 * @return 添加成功返回true，否则返回false
	 */
	public static boolean add(int[] arr, int index, int insert) {
		// 参数合法性判断
		if (index < 0 || index > arr.length - 1) {
			System.out.println("Input Parameter is Invalid!");
			// 方法运行失败！！！
			return false;
		}
		
		/*
		 arr[9] = arr[8];
		 arr[8] = arr[7];
		 arr[7] = arr[6];
		 arr[6] = arr[5];
		 arr[i] = arr[i - 1];
		 arr[i + 1] = arr[i];
		 
		 arr[5] = 20;
		 */
		for (int i = arr.length - 1; i > index; i--) {
			arr[i] = arr[i - 1];
		}
		
		arr[index] = insert;
		
		return true;
	}
}

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

/*
存在一个数组，数组中的元素为
	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占位！！！
*/

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo5 {
	public static void main(String[] args) {
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
		remove(array, 9);
		
		System.out.println(Arrays.toString(array));
	}
	/*
	1.5 删除数组中的指定下标的元素【难点】
	存在一个数组，数组中的元素为
		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占位！！！
	推理过程:
		    从删除位置开始，之后的元素整体向前移动，
		并且需要在数组原本最后一个位置上


                        
                        
                            
                            版权声明：本文来源CSDN，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。

                            原文链接：https://blog.csdn.net/qq_42581682/article/details/104359501

                            站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。


                            
                                
                                    
                                    发表于 2020-02-29 21:28:23
                                
                                阅读 ( 1399 )
                                分类：


                

    
        
            你可能感兴趣的文章
            
                
                
                    去年秋招整理了这份后端开发的核心面试题（偏Java），献给正在校招的你
                    1101 浏览
                
                
                
                    JAVA实习生面试问题
                    965 浏览
                
                
                
                    渲染流程（下）：HTML、CSS和JavaScript，是如何变成页面的？
                    1004 浏览
                
                
                
                    java web生态系统简析
                    497 浏览
                
                
                
                    4月TIOBE编程排行榜出炉，Java稳坐第一
                    690 浏览
                
                
                
                    通俗的讲，Java后端到底是干什么的？语言工程师到底是啥？你是工程师吗？
                    661 浏览
                
                
                
                    前端开发和后端开发（java）都是干什么的？前端和Java那个好？
                    707 浏览
                
                
                
                    告急,Java岗位急缺人！
                    741 浏览
                
                
                
                    java工程师性价比更高_对于工程师而言，简单的ux有时更少，而更多则简单
                    674 浏览
                
                
            
        
        
            精选的优质文章
            
                
                
                    也许 Go 开发可以更简单！
                    10504 浏览
                
                
                
                    如何使用 Golang 日志监控你的应用程序？
                    11983 浏览
                
                
                
                    从Go语言实现模板设计模式浅谈Go的抽象能力
                    14027 浏览
                
                
                
                    阿里云基于 Go 的微服务架构分享
                    23904 浏览
                
                
                
                    java是否会被取代？Go会否给Java带来冲击？
                    28433 浏览
                
                
                
                    千万级规模高性能、高并发的网络架构经验分享
                    29975 浏览
                
                
                
                    阿里部分面试题汇总,对想进阿里的同学非常实用
                    62276 浏览
                
                
                
                    实用好文：知乎实时数仓架构实践及演进
                    31297 浏览
                
                
                
                    支撑马蜂窝「双11」营销大战背后的技术架构
                    228258 浏览
                
                
                
                    想进大厂？50个多线程面试题，你会多少？（一）
                    23029 浏览
                
                
            
        

    



                
                    0 条评论
                    
                        
                        
                        
                            
                                请先 登录 后评论