数组Ⅱ

数组地址转移

其实很简单，简单理解，就是 a = b,理解ab都是一个啦,就看b

数组操作

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]);
   /*
2. 报错
3. 30 30 50
4. 100 100 50 true
5. 30 100 50
6. 50 100 50
7. 30 100 0
   */
   }
   问题总结:

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];
2. 数组作为方法的参数
2.1 还是比葫芦画瓢
arr1[0] ?
arr1[5] ?
20, 0
赋值操作完成的是对于元素直接内容的转换，不涉及数组地址转
移
3.
是否可以展示数组中 arr[0] arr[5]元素的空间首地址
不好意思，不能！！！
public static void main(String[] args) {
}
/*
(String[] args)
String[] args 就是给数组作为方法参数格式，这里main方
法需要的参数是一个String 类型的数组
格式：
public static 返回值类型 方法名(数据类型[] 数组参数
名)
数组是可以作为方法的返回值
【BUT】
在我没有演示，讲解数组作为返回值使用的情况下，任何人不得
使用数组作为返回值
以防万一你遇到一些你想不到的错误！！！
/
2.2 数组作为参数分析过程
/
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:
   指定在数组中查询的元素
   2.3 方法实现和文档注释
   (int[] arr, int find)
   方法声明:
   public static int indexOf(int[] arr, int find)
   /
   /*

• 在指定数组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中保存的数据
  2.4 方法验证和传参方式
  return index;
  }
  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
  */
  2.5 方法运行内存图【难点】
  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.6 总结
  2.7 练习
  2.7.1 保存数据到数组中

1. 数组作为方法参数的固定格式
   (数据类型[] 数组参数名)
2. 数组作为方法的实际参数的固定格式
   (数组名)
3. 数组名作为方法的参数，实际传递的是数组空间首地址，就是和
   数组地址转移问题是一致的
4. 方法执行需要参数，如果没有给予对应格式的实际参数，直接报
   错
   /*
   需求
   完成一个方法，给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(“方法调用之前：”);
  2.7.2 使用A数据，替换指定数组中B数据
  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;
  }
  }
  }
  /
  需求:
  使用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();
  }
  /*
  2.7.3 逆序数组
• 使用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;
  }
  }
  }
  }
  /
  需求:
  存在一个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};

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;
  }
  }
  }