java_周总结
1 数组地址转移问题
public static void main(String[] args) {
int[] arr1 = new int[10];
int[] arr2 = new int[10];
arr1[0] = 10;
arr2[0] = 20;
System.out.println("arr1[0]:" + arr1[0]);
System.out.println("arr2[0]:" + arr2[0]);
arr1[5] = 50;
arr2 = arr1;
arr1[0] = 30;
arr2[0] = 100;
System.out.println("arr1[0]:" + arr1[0]);
System.out.println("arr2[0]:" + arr2[0]);
System.out.println("arr2[5]:" + arr2[5]);
/*
1. 报错
2. 30 30 50
3. 100 100 50 true
4. 30 100 50
5. 50 100 50
6. 30 100 0
*/
}
问题总结:
1.
int[] arr1 = new int[20];
int[] arr2 = new int[10];
arr1 = arr2;
arr1[15] ???; 错误的
arr1 和 arr2 执行的空间为同一个数组空间
2.
int[] arr1 = new int[10];
int[] arr2 = new int[10];
arr1[0] = 10;
arr2[0] = 20;
arr2[5] = 100;
arr1[0] = arr2[0];
arr1[0] ?
arr1[5] ?
20, 0
赋值操作完成的是对于元素直接内容的转换，不涉及数组地址转移
3.
是否可以展示数组中 arr[0] arr[5]元素的空间首地址
不能
2 数组作为方法的参数
public static void main(String[] args) {
}
/*
(String[] args)
String[] args 就是给数组作为方法参数格式，这里main方法需要的参数是一个String 类型的数组
格式：
public static 返回值类型 方法名(数据类型[] 数组参数名)
数组是可以作为方法的返回值
【BUT】
在我没有演示，讲解数组作为返回值使用的情况下，任何人不得使用数组作为返回值
以防万一你遇到一些你想不到的错误！！！
*/
2.1 数组作为参数分析过程
/*
a. 在一个int类型数组中，存储的内容是1 ~ 10
int[] arr = {10, 8, 35, 67, 31, 25, 11, 30, 28, 99};
使用代码找出，元素 == 30 所在下标位置
找出元素30对应的下标位置
1. 这里需要利用循环遍历数组，查询操作
2. 查询结果不确定，有可能找到，有可能找不到
3. 在查询之前我们假设对应的数据时不存在的
-1 作为保存目标数据的初始值
方法分析：
固定格式:
public static 不要问
返回值类型:
void:
没有返回值，功能变成数据找到直接打印，没有返回到方法外，这是一个黑盒
方法。黑盒方法是数据传入之后，没有任何的返回
int:
返回指定元素的下标位置，没有找到返回-1
方法名:
indexOf
获取指定元素对应下标
形式参数列表:
int[] arr:
查询数据的源数组，在哪一个数组中进行查询操作,这里需要一个int类型数组
int find:
指定在数组中查询的元素
(int[] arr, int find)
方法声明:
public static int indexOf(int[] arr, int find)
*/
2.2 方法实现和文档注释
/**
* 在指定数组arr中，查询指定元素find所在的下标位置，找到返回值大于等于0，没有找到
* 返回-1
*
* @param arr 查询数据的源数据数组，int类型数组
* @param find 指定在数组中查询的数据，也是对应int类型
* @return 找到指定元素，返回值大于等于0，否则返回-1
*/
public static int indexOf(int[] arr, int find) {
// 假设查询的数据不存在
int index = -1;
// 遍历整个数组
for (int i = 0; i < arr.length; i++) {
// 发现数组中下标为i的元素和find一致，找到内容，保存下标
if (find == arr[i]) {
index = i;
// 终止循环
break;
}
}
// 返回index中保存的数据
return index;
}
2.3 方法验证和传参方式
class Demo2 {
public static void main(String[] args) {
int[] array = {10, 8, 35, 67, 31, 25, 11, 30, 28, 99};
int find = 13;
// 调用的方法需要数组作为方法的参数，
// 这里传入【数组名】
int index = indexOf(array, find);
if (index >= 0) {
System.out.println("index : " + index);
} else {
System.out.println("Not Found!");
}
}
/**
* 在指定数组arr中，查询指定元素find所在的下标位置，找到返回值大于等于0，没有找到
* 返回-1
*
* @param arr 查询数据的源数据数组，int类型数组
* @param find 指定在数组中查询的数据，也是对应int类型
* @return 找到指定元素，返回值大于等于0，否则返回-1
*/
public static int indexOf(int[] arr, int find) {
// 假设查询的数据不存在
int index = -1;
// 遍历整个数组
for (int i = 0; i < arr.length; i++) {
// 发现数组中下标为i的元素和find一致，找到内容，保存下标
if (find == arr[i]) {
index = i;
// 终止循环
break;
}
}
// 返回index中保存的数据
return index;
}
}
2.4 方法运行内存图
2.5 总结
- 数组作为方法参数的固定格式
(数据类型[] 数组参数名) - 数组作为方法的实际参数的固定格式
(数组名) - 数组名作为方法的参数，实际传递的是数组空间首地址，就是和数组地址转移问题是一致的
- 方法执行需要参数，如果没有给予对应格式的实际参数，直接报错。
2.6 练习题
2.6.1 保存数据到数组中
/*
需求
完成一个方法，给int类型数组保存的元素进行赋值操作，所有元素内容全部赋值为100
方法分析:
固定格式:
public static 不要问
返回值类型:
void 没有返回值
方法名:
assignIntArray
赋值int类型数组
形式参数列表:
int[] arr 这里需要一个int类型数组
方法声明:
public static void assignIntArray(int[] arr)
*/
/**
* 传入一个int类型数组，把当前int类型数组中所有的元素全部赋值为100
*
* @param arr int类型数组
*/
public static void assignIntArray(int[] arr) {
// 利用循环遍历数组，循环赋值操作
for (int i = 0; i < arr.length; i++) {
arr[i] = 100;
}
}
class Demo3 {
public static void main(String[] args) {
int[] intArray = new int[10];
System.out.print("方法调用之前：");
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + " ");
}
System.out.println();
assignIntArray(intArray);
System.out.print("方法调用之后：");
for (int i = 0; i < intArray.length; i++) {
System.out.print(intArray[i] + " ");
}
System.out.println();
}
/**
* 传入一个int类型数组，把当前int类型数组中所有的元素全部赋值为100
*
* @param arr int类型数组
*/
public static void assignIntArray(int[] arr) {
// 利用循环遍历数组，循环赋值操作
for (int i = 0; i < arr.length; i++) {
arr[i] = 100;
}
}
}
2.6.2 使用A数据，替换指定数组中B数据
/*
需求:
使用A数据，替换指定数组中B数据
例如:
原始数据:
int[] arr = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
替换所有元素值 == 5 ==> 100
结果 Result
int[] arr = {1, 2, 3, 4, 100, 1, 2, 3, 4, 100}
方法分析:
固定格式:
public static 不要问
返回值类型:
void 没有返回值
方法名:
replace 替换
形式参数列表:
这里需要三个参数:
a. 指定的数组 int[] arr
b. A数据 int newNum
c. B数据 int oldNum
(int[] arr, int oldNum, int newNum);
方法声明:
public static void replace(int[] arr, int oldNum, int newNum)
*/
/**
* 使用newNum数据替换指定数组arr中，oldNum数据
*
* @param arr 指定的int类型数据
* @param oldNum 需要被替换的数据，int类型
* @param newNum 替换使用的新数据，int类型
*/
public static void replace(int[] arr, int oldNum, int newNum) {
for (int i = 0; i < arr.length; i++) {
if (oldNum == arr[i]) {
arr[i] = newNum;
}
}
}
class Demo4 {
public static void main(String[] args) {
int[] arr = {1, 11, 111, 1111, 11111, 1, 11, 111, 1111, 11111};
System.out.print("方法调用之前：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
replace(arr, 11, 22222);
System.out.print("方法调用之后：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
/**
* 使用newNum数据替换指定数组arr中，oldNum数据
*
* @param arr 指定的int类型数据
* @param oldNum 需要被替换的数据，int类型
* @param newNum 替换使用的新数据，int类型
*/
public static void replace(int[] arr, int oldNum, int newNum) {
for (int i = 0; i < arr.length; i++) {
if (oldNum == arr[i]) {
arr[i] = newNum;
}
}
}
}
2.6.3 逆序数组
/*
需求:
存在一个int类型数组，使用方法逆序数组中的元素
例如：
int[] arr =
{1, 2, 3, 4, 5};
执行之后
{5, 4, 3, 2, 1};
方法分析：
固定格式:
public static 不要问
返回值类型:
void
方法名:
reverse
形式参数列表:
int[] arr 这里需要一个int类型数组
方法声明：
public staitc void reverse(int[] arr)
*/
/**
* 数组逆序
*
* @param arr 需要被逆序的int类型数组
*/
public staitc void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
/*
前提:
{11, 13, 25, 68, 90};
1.
i = 0;
temp = arr[0]; temp ==> 11
arr[0] = arr[arr.length - 1 - i]; arr[4] ==> 90 arr[0] = 90
arr[arr.length - 1 - i] ==> arr[4] = 11;
2
i = 1;
temp = arr[1] temp = 13
arr[1] = arr[5 - 1 - 1]; arr[1] = 68 arr[3] = 68
arr[3] = temp; arr[3] ==> 13
*/
}
}
class Demo5 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.print("方法调用之前：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
reverse(arr);
System.out.print("方法调用之后：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
/**
* 数组逆序
*
* @param arr 需要被逆序的int类型数组
*/
public static void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
}
2.6.4 作业题
a. 找出数组中最大值的下标位置
/*
找出数组中最大值的下标位置
*/
class Demo7 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int max = 0;
for (int i = 0;i < arr.length;i++) {
if (arr[max] < arr[i]) {
max = i;
}
}
System.out.println(max);
}
}
b. 找出数组中最小值的下标位置
/*
找出数组中最小值的下标位置
*/
class Demo8 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int min = 0;
for (int i = 0;i < arr.length;i++) {
if (arr[min] > arr[i]) {
min = i;
}
}
System.out.println(min);
}
}
c. 在指定位置插入指定元素【难点】
存在一个数组，数组中的元素为
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
要求
1. 0是无效元素，仅占位使用
2. 当前数组中【有效元素】个数为9
需求
在该数组中的指定下标位置放入指定元素
/*
c. 在指定位置插入指定元素【难点】
存在一个数组，数组中的元素为
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
要求
1. 0是无效元素，仅占位使用
2. 当前数组中【有效元素】个数为9
需求
在该数组中的指定下标位置放入指定元素
*/
public class InsertArray {
public static void main(String[] args) {
int index = 2;
int value = 5;
int[] array = new int[]{1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
int[] newArray = new int[array.length + 1];
for (int i = 0; i < array.length; i++) {
newArray[i] = array[i];
}
for (int i = newArray.length - 1; i > index; i--) {
newArray[i] = newArray[i - 1];
}
newArray[index] = value;
array = newArray;
System.out.println(Arrays.toString(array));
}
}
d. 删除数组中的指定下标的元素【难点】
存在一个数组，数组中的元素为
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占位！！！
/*
d. 删除数组中的指定下标的元素【难点】
存在一个数组，数组中的元素为
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)
*/
public class Demo10 {
public static void main(String[] args) {
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
remove(array, 9);
}
/**
* 删除数组中指定下标元素的内容
*
* @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;
}
}
3 笔记整理
