JavaSE 04 数组

1、数组

用于保存一组数的容器。

2、数组的优点

⑴ 代码简洁，同时开辟一组空间。
⑵ 数组的空间是连续的。
⑶ 分类存储，查找方便。

3、数组的特点

⑴ 数组的声明时，数据类型可以是基本数据类型，也可以是引用数据类型。
⑵ 数据类型已经声明后，其保存的数据类型必须一致。
⑶ 数据本身属于引用数据类型，所以其遵循引用数据类型的存储和使用的特点。
⑷ 数组名存放在栈中，里面保存了堆中的一组连续空间的首项 [0] 的地址值。数组元素保存在堆中，且是连续的。

4、数组的四要素

数据类型 数组名 数组元素（可以是多个） 下标（0 ~ 数组长度 - 1）

5、访问数组的元素

数组名[下标]

6、数组的声明和使用

⑴ 声明： ① 数据类型[ ] 数组名;
② 数据类型 数组名[ ];
示例： int[ ] arr; // 告诉内存要开辟一串空间，数据类型为int类型，数组名【引用名】为arr。但这是还没有真正开辟空间。
⑵ 开辟空间
数组名 = new 数据类型[数组长度];
示例： arr = new int[5];
⑶ 赋值
数组名[下标] = 值;
示例：arr[0] = 10;
⑷ 使用
数组名[下标];
示例：System.out.println(arr[0]); // 10

注意：① 第⑴、⑵步可以合为一步：
数据类型[ ] 数组名 = new 数据类型[数组长度];
示例： String[ ] strs = new String[10];
②下标必须在数组长度的范围之内，否则会报异常：ArrayIndexOutOfBoundsException
③ 数组声明并开辟长度时，必须指定数组的长度，否则会报错：缺少数组维。
④ 数组如果没有显式地赋值，则系统将为其赋予默认值：
int 0
double 0.0
char ‘\u0000’
boolean false
String null
⑤ 声明并初始化数组元素值，可以合并在一起：
double[ ] scores = new double(){2.4, 4.5, 5.6, 7.8};
或
int[ ] numbers = {2, 23, 34, 48, 23};
但是：
int[ ] num;
num = {2, 234, 34, 72};
这是错误的！（错误: 非法的表达式开始）

7、数组使用的类型

⑴ 静态初始化：

① 步骤1：声明数组并初始化数组元素的值
示例：int[ ] numbers = {2, 3, 45, 76, 21};
② 步骤2：使用
示例：System.out.println(numbers[0]);

⑵ 动态初始化：

① 步骤1：声明数组并开辟长度
示例：String[ ] strs = new String[5];
② 步骤2：给数组元素赋值
示例：strs[0] = “ABC”; strs[1] = “DNF”; strs[3] = “Good”
③ 步骤3：使用
示例：System.out.println(strs[1]);

8、数组的简单使用

⑴ 循环打印

数据类型[ ] 数组名 = new 数组类型[ ]{元素值1, 元素值2, …, 元素值n};
for(int i = 0 ;i < 数组名.length; i++){
System.out.println(数组名[i]);
}

示例：
String[ ] strs = new String[ ]{“ABC”, “DNF”, “GOOD”, “Happy”, “Import”};
for (int i = 0 ; i < strs.length; i++) {
System.out.println(strs[i]);
}

⑵ 求和

注意：数据类型需要为数值型
数据类型[] 数组名 = {元素值1, 元素值2, …, 元素值n};
int sum = 0;
for(int i = 0; i < 数组名.length; i++){
sum += 数组名[i];
}

示例：      int[] numbers = {23, 15, 82, 23, 93, 28};
            int sum = 0;
            for (int i = 0; i < numbers.length; i++) {
              sum += numbers[i];
            }
            System.out.println("和为：" + sum); // 和为：264

⑶ 求最值

  注意：数据类型需要为数值型

  ① 求最大值
     示例：
      int[] numbers = {223, 135, 820, 213, 193, 128};
      int max = numbers[0]; // 注意：这里需要<b>将最大值默认为数组的第一个元素【角标为0】</b>
      for (int i = 1; i < numbers.length; i++) { // 因为最大值（max）的声明时，已经将数组的第一个元素的值赋值给了max。所以这里就<b>从角标1开始【即第二个元素】</b>
        if (numbers[i] > max) { // 如果遇到了比max大的值，就更新max
          max = numbers[i];
        }
      }
      System.out.println("最大值为：" + max); // 最大值为：820

  ② 求最小值，并附带角标
     示例：
       int[] nums = {23, 34, 28, 29, 19, 9, 23, 11};
       int min = nums[0];
       int index = 0; // 这里用index变量来保存角标
       for (int i = 1;i < nums.length; i++) {
         if (nums[i] < min) {
           min = nums[i];
           index = i; // 当找到比min小的元素值时，就更新index所保存的角标的值
         }
       }
       System.out.println("最小值为：" + min + ", 其角标为：" + index); // 最小值为：9, 其角标为：5

⑷ 查找

示例：

      import java.util.Scanner;

      Scanner input = new Scanner(System.in);
      String[] usernames = {"Tom", "John", "White", "Danny", "Conan"}; // 定义一个数组名为usernames的数组，里面静态赋值了5个元素值

      System.out.print("请输入用户名：");
      String name = input.next(); // 用于保存用户输入的用户名

      int i = 0; // 这个for循环的循环变量初始值可以放在循环的外面，循环结束后打印输出角标
      for (; i < usernames.length; i++) {
        if (name.equals(usernames[i])) {  // 逐一匹配姓名
          System.out.println("欢迎登录 " + name + "!");
          break; // 找到了就退出循环
        } else if (i == usernames.length - 1) { // 到了usernames数组的最后一项【Conan】，还是没有匹配到
          System.out.println("没有找到该用户!");
        }
      }

      if (i < 5) { // i等于5时，就是没有匹配到姓名【当匹配到时，因为if中有break，所以i就不会再执行i++，所以i这时就等于角标值】
        System.out.println("角标 : " + i);
      }

      input.close();

⑸ 排序 【冒泡排序】

思想：先从角标0开始，让角标0和角标1比较，让较大的那个放到后面。然后让角标1和角标2比较，也让较大的那个放到后面。这样依次比较，<b>最终达到从小到大的排序效果</b>。

    示例：
        int[] nums = {31, 21, 16, 18, 36};  将这个数组从小到大排序
    分析：① 这个nums数组的长度为5，所以需要排序4次。
          ② 第一次排序需要交换4次；第二次排序需要交换3次；第三次排序需要交换2次；第四次排序需要交换1次。

          排序次数             交换次数
              1                  4
              2                  3
              3                  2
              4                  1
          ③ 所以需要使用嵌套for循环来实现排序功能。

    模版：
        for(int i = 1; i < 数组长度; i++){
          for(int j = 0; j < 数组长度 - i; j++){
            根据相邻两个元素值的“大小”，来交换数组[j]和数组[j + 1]的位置
          }
        }

    用嵌套for循环实现上述示例：
       for(int i = 1; i < nums.length; i++){
         for(int j = 0; j < nums.length - i; j++){
           if(nums[j] > nums[j + 1]){
             nums[j] += nums[j + 1];
             nums[j + 1] = nums[j] - nums[j + 1];
             nums[j] = nums[j] - nums[j + 1];
           }
         }
       }

    输出效果：
       排序前:
        31      21      16      18      36
       排序后:
        16      18      21      31      36

9、数组的复杂使用

⑴ 数组的赋值

语法： int[ ] arr1 = {23, 34, 12, 10, 8, 32};
            int[ ] arr2;
            arr2 = arr1; // 数组的赋值

注意：① 基本数据类型赋值时，赋的是一个值（即变量值），而其中一个的改变不会影响到另外一个。
② 引用数据类型赋值时，赋的是一个地址，二者共同引用同一个空间，其中一个的改变会影响到另外一个。

示例： （继续上面的语法代码）

   System.out.println("修改数组arr2前的arr1：");
   for(int j = 0; j < arr1.length; j++){
     System.out.print(arr1[j] + "\t");
   }

   for(int i = 1; i < arr2.length; i += 2){
     arr2[i] = i;
   }

   System.out.println("\n修改数组arr2后的arr1：");
   for(int j = 0; j < arr1.length; j++){
     System.out.print(arr1[j] + "\t");
   }
   System.out.println("\n修改数组arr2后的arr2：");
   for(int j = 0; j < arr2.length; j++){
     System.out.print(arr2[j] + "\t");
   }

输出结果：
修改数组arr2前的arr1：
23    34    12    10    8    32
修改数组arr2后的arr1：
23     1     12    3      8     5
修改数组arr2后的arr2：
23     1     12    3      8     5

因为修改数组arr2后，数组arr1中的元素的值也跟着改变了，所以数组（引用数据类型）的赋值，赋的是地址值。

如果不想出现修改其中一个数组的元素值，另外一个数组的元素值也跟着改变的情况，则需要: 另外开辟一块新的空间，将其中一个数组循环赋值给另外一个数组。
代码：
数据类型[ ] 数组1 = {元素值1, 元素值2, …, 元素值n};
数据类型[ ] 数组2 = new 数据类型[数组1.length];
for(int i = 0; i < 数组1.length; i++){
  数组2[i] = 数组1[i];
}

⑵ 数组的反转

① 方法一【借助于中间变量】:
将数组循环，交换开头和结尾的对应位置，直到数组长度的一半为止。
② 方法二【借助新的数组】:
⒈新建一个长度和旧数组长度一样的新数组；⒉将旧数组倒着赋值给新数组；⒊再将新数组的地址值赋值给旧数组。

 示例：
    int[] nums = {19, 23, 35, 47, 56, 68};
    System.out.println("原数组：");
    for (int i = 0; i < nums.length; i++) {
      System.out.print(nums[i] + "\t");
    }

    System.out.println("\n方法一【借用中间变量】："); // 借用中间变量，来交换元素的位置

    int temp; // 中间变量，在交换数组元素位置时，用于暂时保存元素值
    for (int i = 0, j = nums.length - 1; i < nums.length / 2; i++, j--) { // 只需要交换到数组长度的一半位置即可（奇数长度为：除以2的结果舍掉小数）
      temp = nums[i];
      nums[i] = nums[j];
      nums[j] = temp;
    }

    for (int i = 0; i < nums.length; i++) {
      System.out.print(nums[i] + "\t");
    }

    System.out.println("\n方法二【借用新数组】："); // 借用新数组

    int[] numsNew = new int[nums.length];
    for (int i = nums.length - 1, j = 0; i >= 0; i--, j++) { // 将旧数组倒着赋值给新数组
      numsNew[j] = nums[i];
    }
    nums = numsNew; // 将新数组的地址值赋值给旧数组

    for (int i = 0; i < nums.length; i++) {
      System.out.print(nums[i] + "\t");
    }

 输出结果：
      原数组：
      19      23      35      47      56      68
      方法一【借用中间变量】：
      68      56      47      35      23      19
      方法二【借用新数组】：
      19      23      35      47      56      68

⑶ 数组的添加【在数组的尾部添加】

数组的长度一旦固定，就不能再次更改。所以所有数组的添加都要新建数组。
添加步骤：① 创建一个新的数组，长度为旧数组长度 + 1。
② 遍历旧的数组，并赋值到新的数组。数组角标一一对应。
③ 新数组的尾部（length - 1） = 要添加的元素。
④ 将新数组的地址值赋值给旧的数组。

 示例： int[] nums = {23, 54, 31, 34};

        int[] numsNew = new int[nums.length + 1]; // 新建一个长度比旧数组长度多1的新数组 ①
        for(int i = 0; i < nums.length; i++){ // 循环遍历旧数组，并将元素值一一对应地复制给新数组 ②
          numsNew[i] = nums[i];
        }

        int add = 10; // 要插入的数组元素 ③
        numsNew[numsNew.length - 1] = add;

        nums = numsNew; // 将新数组的地址值赋值给旧数组。 ④

     遍历nums的结果为：23      54      31      34      10

⑷ 数组的添加【创建数组时，开辟足够长的长度】

添加步骤：① 新建足够长的数组。
② 定义一个记录当前数组元素总量的int类型的变量。
③ 在添加元素之前，先要判断当前记录元素总量的变量是否已经等于或大于数组的长度。如果大于，则不要添加，否则下角标越界。
④ 添加新元素的方法为：数组名[记录元素总量的变量] = 元素；
⑤ 每添加一个新的元素，就让记录元素总量的变量加1。
示例：
int[] nums = new int[100]; // 假定100够用了
int total = 0; // 记录nums数组的元素总量【当前 为0个】

if(total >= nums.length){ // 判断是否已经无法再添加元素了
     return;
}

nums[total] = 10; // 添加元素
total++; // 让total加1

⑸ 数组的插入

插入步骤：① 创建一个新数组，长度比旧数组长度多1。
② 将旧数组的元素值循环赋值给新数组。
③ 新数组: 从要插入的 index角标位置的下一位开始， 循环将元素向后移动一位。
④ 将要插入数组元素，赋值给新数组[index]。
⑤ 将新数组的地址值赋值给旧数组。

   示例： String[] names = {"John", "White", "Tom", "Danny"};
            String[] namesNew = new String[names.length + 1]; // ①
            for(int i = 0; i < names.length; i++){ // ②
              namesNew[i] = names[i];
            }

            String addName = "Bill"; // 要插入的数组元素
            int index = 2; // 要插入的角标位置
            for(int j = namesNew.length - 1; j > index; j--){ // ③
              namesNew[j] = namesNew[j - 1];
            }

            namesNew[index] = addName; // ④
            names = namesNew; // ⑤

      遍历names的结果为：John    White   Bill    Tom     Danny

⑹ 数组元素的删除

删除步骤：① 首先找到要删除的数组元素的所在位置（找下标）。
② 从要删除的元素的位置开始，循环前移每个元素的位置。 直到倒数第二个数组元素。
③ 将数组的最后一个元素赋为初始值（null、false或0 等）。

示例：

public class Test {

public static void main(String[] args) {
int[] nums = {23, 31, 49, 29, 3, 19};

for (int a = 0; a < nums.length; a++) { 
  System.out.print(nums[a] + "\t"); // 23      31      49      29      3       19
}

System.out.println();

int num = 49; // 假定要删除49，这个数组元素

int index = 0;
for (int i = 0; i < nums.length; i++) {
  if (num == nums[i]) {
    index = i;
    break;
  }
}

for (int j = index; j < nums.length - 1; j++) {
  nums[j] = nums[j + 1];
}
nums[nums.length - 1] = 0;

int[] newNums = new int[nums.length - 1];
for (int k = 0; k < newNums.length; k++) {
  newNums[k] = nums[k];
}
nums = newNums;

for (int a = 0; a < nums.length; a++) {
  System.out.print(nums[a] + "\t"); // 23      31      29      3       19
}
System.out.println();
}
}

10、二维数组

可以称为多个一维数组的组合。
int[ ][ ] nums;
也可以写成：int[ ] nums[ ];【配合着内存图，就可以很清楚地理解二维数组是什么】

Java也支持三维、四维…
int[ ][ ][ ] nums;
int[ ][ ][ ][ ] nums;

特点：
⑴ 同样地，二维数组也具备四要素（数据类型，数组名，数组元素，下标【行下标和列下标，都是从0开始】）。
⑵ 访问二维数组中的某个元素，需要通过
数组名[行下标][列下标] 来访问。
⑶ 数组名.length 来获取二维数组的长度（行数）；
数组名[行数].length可以获取某一行的列数。

11、二维数组的声明和使用

⑴ 动态初始化：

① 声明并开辟长度（二维数组的长度）。
   ⒈ 知道行数和列数：
    数据类型[ ][ ] 数组名 = new 数据类型[行数][列数];
    2.不知道列数：
    数据类型[ ][ ] 数组名 = new 数据类型[行数][ ];

  注意：列数可以省略，但是行数不能省略。

② 赋值：
  ⒈ 固定列数：
     for(int i = 0; i < 数组名.length; i++){
       for(int j = 0; j < 数组名[i].length; j++){
          数组名[i][j] = 元素值;
       }
     }

  ⒉ 不固定列数：
      for(int i = 0; i < 数组名.length; i++){
        数组名[i] = new 数据类型[数组长度];
        for(int j = 0; j < 数组名[i].length; j++){
          数组名[i][j] = 元素值;
        }
      }

   ③ 使用：
      for(int i = 0; i < 数组名.length; i++){
        for(int j = 0; j < 数组名[i].length; j++){
          数组名[i][j]; // 数组元素
        }
      }

⑵ 静态初始化：

数据类型[ ][ ] 数组名 = new 数据类型{{ … }, { … }, { … }, …};
或
数据类型[ ][ ] 数组名 = {{ … }, { … }, { … }, …};

12、增强for循环

属于一种循环机制，是JDK5.0之后出现的新特性。
它可以遍历集合或数组。

语法： for(元素的数据类型 元素名 : 数组名){
元素名 // 操作每一个元素
}

执行原理：每次从数组或集合中取出对应的元素，直到取不出元素为止。

特点：⑴ 每次只能移动一位。
⑵ 只能向下移动。
⑶ 只能访问，不能修改。

示例：
⑴ 遍历一维数组
int[] numbers = {23, 37, 48, 54, 30};
for(int number : numbers){
System.out.print(number + “\t”);
}
输出结果：23 37 48 54 30

 ⑵ 遍历二位数组
    char[][] chs = {{'a', 'b'}, {'c', 'd', 'e'}, {'f'}};

    for (char[] ch : chs) {
      for(char c : ch){
        System.out.print(c + "\t");
      }
      System.out.println();
    }

   输出结果： a       b
              c       d       e
              f