Java学习总结
数组
数组的概念
数组:一组连续的储存空间,储存多个相同数据类型的值
为什么要用到数组
在开发中可能会存在很多情况下,相同数据类型都是数据大量使用的情况,按照目前我们所学的方式,
在代码中可能就会出现很多行的变量定义,会导致以下问题:
1. 代码过于臃肿!!!
2. 代码阅读性极差!!!
3. 数据维护性极差!!!
4. 数据没有任何的复用度可言,操作非常繁琐!!!
数组的定义
数据类型[] 数组名 = new 数据类型[容量];
/*
赋值左侧
数据类型:
告知编译器,当前数组中能够保存的数据类型到底是什么?并且在确定数据类
型之后,整个数组中保存的数据类型无法修改!!!
[]:
1. 告知编译器这里定义的是一个数组类型数据。
2. 明确告知编译器,数组名是一个【引用数据类型】
数组名:
1. 操作数据非常重要的数据!!!
2. 数组名是一个【引用数据类型】
小拓展: int(*) (void *, void *)
赋值号右侧:
new:
申请【XX】内存空间,并且清空整个内存空间中所有二进制位,所有的二进制
位都是0
数据类型:
前后呼应,告知编译器这里支持存储的数据类型到底是什么?
[容量]:
容量==> Capacity
告知编译器,当前数组中能够存放的对应数据类型的数据,最大存储多少
个!!
【注意】
一旦确定容量,针对于当前数组,后期容量无法修改
*/
数组的下标
规定
数组中的下标是从0开始,到数组的容量 - 1
例如:
数组容量为10
有效下标范围: 0 ~ 9
超出有效下标范围,都是无效下标,后期考虑数组处理异常问题,负数使用问题
操作会出现的问题:
1. 数组下标越界
ArrayIndexOutOfBoundsException
数组内存分析图
引用数据类型
生活中
文章中如果出现了对于其他文章的引用操作,会存在对应角标,用于在文章中进行跳转操作!!!
快递信息
开发中引用数据类型
用于保存其他内存空间的首地址,保存地址之后,CPU可以通过对应的引用数据类型,得到对应的地址,从而访问地址对应内存空间。
获取数组容量的方式
数组名.length 属性
当前数组的属性length是要占用一定的数组空间的,属于数组中的内容,这就是为什么数组中占用的空间要比存储数据计算空间略大一些。
*/
数组地址转移问题(重点)
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]);
}
}
数组地址转移图
数组和方法之间的关系
/*
Java中如何数组成为方法的参数,已经使用方式
*/
public static void main(String[] args) {
}
/*
格式:
public static returnType methodName(arrayType[] arrayName)
arrayName是一个数组类型的变量,引用数据类型的变量
*/
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]);
}
}
}
数组算法
完成一个数组逆序过程
/*
静态数组
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;
}
}
找出数组中最大值所在下标位置
/*
方法分析:
public static 不要问
返回值类型:
找出对应元素的下标位置,返回值为int类型
方法名:
minIndexOfArray
形式参数列表:
(int[] array)
方法声明:
public static int minIndexOfArray(int[] array)
*/
/**
* 找出数组中最小值的下标位置
*
* @param array int类型数组
* @return 返回值是当前数组中最小值的下标位置
*/
public static int minIndexOfArray(int[] array) {
int minIndex = 0;
for (int i = 1; i < array.length; i++) {
if (array[minIndex] > array[i]) {
minIndex = i;
}
}
return minIndex;
}
找出数组中指定元素的下标位置
/*
方法分析:
public static
返回值类型:
返回值是数组的下标位置,为int类型
方法名:
indexOf
形式参数列表:
1. int类型数组
2. 告知方法指定查询的数据
(int[] array, int find);
方法声明:
public static int indexOf(int[] array, int find)
*/
/**
* 找出指定元素的下标位置
*
* @param array 指定的int类型数组
* @param find 指定查询的数据,为int类型
* @return 找到对应下标位置,返回值大于等于0,没有找到返回-1
*/
public static int indexOf(int[] array, int find) {
// 这里假设找不到对应的数据
int index = -1;
// 利用循环遍历数组
for (int i = 0; i < array.length; i++) {
// 发现存在数据和指定find数据一致
if (find == array[i]) {
// 保留下标
index = i;
// 没有继续循环下去的必要,终止循环
break;
}
}
return index;
}
获取数组中指定下标的元素
/**
* 找出指定下标的元素
*
* @param array 指定的数组
* @param index 指定的下标位置
* @return 对应当前下标的元素,为int类型
*/
public static int get(int[] array, int index) {
// 参数合法性判断的思想
if (index > array.length - 1 || index < 0) {
System.out.println("Input Parameter is Invalid!");
System.exit(0);
}
return array[index];
}
找出指定元素在指定数组中所有下标位置 【难点】
/*
要求:
a. 不允许在方法内打印展示
b. 考虑多个数据情况
c. 需要在方法外获取到下标数据信息
d. 不允许使用数组作为返回值
【重点】
1. 尾插法思想,计数器同时也是下一次存放数据的位置
2. 数组作为方法参数之后,是可以近似数据传导
*/
package com.qfedu.a_array;
/**
* 【重点】
*
* @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;
}
}
在指定位置插入指定元素【难点】
/*
存在一个数组,数组中的元素为
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
要求
1. 0是无效元素,仅占位使用
2. 当前数组中【有效元素】个数为9
需求
在该数组中的指定下标位置放入指定元素
【重点】
1. 空数据,无效数据思想
2. 数据的移动过程,粗加工,细打磨过程
3. 时间消耗问题
*/
代码
package com.qfedu.a_array;
import java.util.Arrays;
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;
}
}
删除数组中的指定下标的元素【难点】
/*
存在一个数组,数组中的元素为
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占位!!!
推理过程:
从删除位置开始,之后的元素整体向前移动,
并且需要在数组原本最后一个位置上存放元素0,0
是无效元素,占位使用
arr[3] = arr[4];
arr[4] = arr[5];
arr[5] = arr[6];
arr[6] = arr[7];
arr[7] = arr[8];
arr[8] = arr[9];
arr[i] = arr[i + 1];
arr[i - 1] = arr[i];
arr[9] = 0;
方法分析:
public static 不要问
返回值类型:
boolean
方法名:
remove
形式参数列表:
1. 删除数据的数组
2. 指定删除数据的下标位置
方法声明:
public static boolean remove(int[] arr, int index)
*/
/**
* 删除数组中指定下标元素的内容
*
* @param arr 源数据数组,int类类型
* @param index 指定删除的下标位置
* @return 删除操作成功返回true,失败返回false
*/
public static boolean remove(int[] arr, int index) {
// 参数合法性判断
// index < 0 || index >= arr.length
if (index < 0 || index > arr.length - 1) {
System.out.println("Input Parameter is Invalid");
return false;
}
/*
arr[3] = arr[4];
arr[4] = arr[5];
arr[5] = arr[6];
arr[6] = arr[7];
arr[7] = arr[8];
arr[8] = arr[9];
arr[i] = arr[i + 1];
从删除位置开始,到数组的最后一个有效元素位置结束
*/
for (int i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
// 最后一位数据赋值为0,占位,同时告知用户这是一个无效数据
arr[arr.length - 1] = 0;
return true;
}
}
找出数组中最大值元素,放到下标为0的位置
int[] arr = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
System.out.println(Arrays.toString(arr));
// 假设最大值的下标位置为0
int index = 0;
// 这里一定可以得到最大值所在的下标位置
for (int i = 1; i < arr.length; i++) {
if (arr[index] < arr[i]) {
index = i;
}
}
// 交换数据
if (index != 0) {
int temp = arr[0];
arr[0] = arr[index];
arr[index] = temp;
}
System.out.println(Arrays.toString(arr));
接上一题,找出数组中剩余元素的最大值,放到下标为1的位置
int index1 = 1;
for (int i = 2; i < arr.length; i++) {
if (arr[index1] < arr[i]) {
index1 = i;
}
}
if (index1 != 1) {
int temp = arr[1];
arr[1] = arr[index1];
arr[index1] = temp;
}
System.out.println(Arrays.toString(arr));
再接上一题,找出数组中剩余元素的最大值,放到下标为2的位置
int index2 = 2;
for (int i = 3; i < arr.length; i++) {
if (arr[index2] < arr[i]) {
index2 = i;
}
}
if (index2 != 2) {
int temp = arr[2];
arr[2] = arr[index2];
arr[index2] = temp;
}
System.out.println(Arrays.toString(arr));
选择排序算法
package com.qfedu.a_array;
import java.util.Arrays;
public class Demo7 {
public static void main(String[] args) {
int[] arr = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
System.out.println(Arrays.toString(arr));
selectSort(arr);
System.out.println(Arrays.toString(arr));
}
/*
* 选择排序算法
* 方法分析:
* public static 不要问
* 返回值类型:
* void
* 方法名:
* selectSort
* 形式参数列表:
* 需要处理一个int类型数据
* (int[] arr)
*
* 方法声明:
* public static void selectSort(int[] arr)
*/
/**
* 选择排序算法
*
* @param arr 需要进行排序的int类型数据
*/
public static void selectSort(int[] arr) {
// 外层循环控制核心算法的循环次数
for (int i = 0; i < arr.length - 1; i++) {
// 从index位置开始找寻极值
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[index] > arr[j]) {
index = j;
}
}
if (index != i) {
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
}
}
Arrays数组工具类使用
数组的工具类:
提供了数组操作的基本方法
sort(int[] arr);
经过XXX,XXX,XXX三个大牛优化的利用XXX技术完成的快速排序算法
binarySearch(int[] arr, int find);
二分法查询,要求数组是有序的。
toString(任何类型数组);
把数组内容作出一个String类型字符串返回值
{1, 3, 5, 7, 9} ==> [1, 3, 5, 7, 9]