Java——数组

Java——数组

一、数组概念和特点

数组（array） 就是多个相同类型的数据按一定顺序排列的集合

1. 数组的概念

• 数组名
• 下标（或脚标、索引）(index)
• 元素(element)
• 数组的长度(length)
  

2. 数组的特点：

• 数组的长度一旦确定就不能修改
• 存取元素的速度快，因为可以通过 下标，直接定位到任意一个元素。

二、数组的语法

• 数组的初始化

  数组初始化分为：静态初始化 和 动态初始化

  动态初始化： 数组根据不同的类型初始化对应的 默认值

  // 动态初始化数组
  int[] arr3 = new int[5];
  

  静态初始化： 数组初始化值为字面量的值

  // 1. 静态初始化
  int[] arr = new int[]{23, 43, 3, 26};
  // 1.2 静态初始化（简写）
  int[] arr2 = {34, 23, 324, 234};
  

• 数组元素的赋值和取值

  数组是通过索引访问元素的， 索引从 0 开始

  int[] arr = new int[5];
  // 1. 数组的赋值
  arr[0] = 97;
  // 2. 数组的取值
  System.out.println(arr[0]);
  

• 3. 数组的遍历

  int[] nums = {1, 34, 343, 3, 5};
  for (int i = 0; i < nums.length; i++) {
      System.out.print(nums[i] + " ");
  }
  

三、数组的使用

• 求和：

  使用数组保存学生成绩，求 总分数 和 平均分

  // 定义一个成绩数组， 计算总分数和平均分
  int[] scores = {77, 43, 43, 88, 90, 100};
  int sum = 0;
  for (int i = 0; i < scores.length; i++) {
      sum += scores[i];
  }
  int avg = sum / scores.length;
  System.out.println("总分为：" + sum + "平均分为： " + avg);
  

• 求最大值

  使用数组保存学生成绩，求 最高分数

  // 求数组的最大值
  int[] scores = {77, 43, 43, 88, 90, 100};
  int max = scores[0];
  for (int i = 1; i < scores.length; i++) {
      if (scores[i] > max) {
          max = scores[i];
      }
  }
  System.out.println("最高分是： " + max);
  

• 求最小值

  使用数组保存学生成绩，求 最低分数

  // 求数组的最小值
  int[] scores = {77, 43, 43, 88, 90, 100};
  int min = scores[0];
  for (int i = 1; i < scores.length; i++) {
      if (scores[i] < min) {
          min = scores[i];
      }
  }
  System.out.println("最低分是： " + min);
  

• 查找指定的元素

  使用数组保存学生成绩，查找 90 分的成绩 下标

  int[] scores = {77, 43, 43, 88, 90, 100};
  // 假设我要找的数字是90
  int num = 90;
  int index = -1;
  for (int i = 0; i < scores.length; i++) {
      if(num == scores[i]){
          index = i;
          break;
      }
  }
  if(index == -1)
      System.out.println("该数组中没有你要查找的元素");
  else
      System.out.println("你要查找的元素下标是： " + index);
  

四、数组进阶

冒泡排序

①. 从头比较相邻的元素。如果第一个比第二个大，就 交换 他们两个。
②. 匹配到结尾之后，最后的元素就会是最大的数。
③. 从头重新比较 交换，依次把最大的元素都放到后面，直到没有任何一对数字需要比较。

代码实现思路： 使用嵌套 for循环实现

外层循环： 从 0 开始 到 数组长度 -1次， 当前代码就是 i = 0、1、2、3、4， 下标从因为从 0 开始 也就是循环 5 次
内层循环： 第一次循环 数组长度 -1-i 5 次， 最后一次循环 数组长度-1-i 1 次
循环体： 每次循环根据条件， 把大的数字放后面

// 将成绩从高到低排序
int[] scores = {77, 43, 34, 88, 90, 100};
// 临时变量
int temp = 0;
for (int i = 0; i < scores.length - 1; i++) {
    for (int j = 0; j < scores.length - 1 - i; j++) {

        if (scores[j] > scores[j + 1]) {
            temp = scores[j];
            scores[j] = scores[j + 1];
            scores[j + 1] = temp;
        }
    }
}
System.out.println(Arrays.toString(scores));

[34, 43, 77, 88, 90, 100]

选择排序

①. 第一次从未排序的数据元素中选出最小的一个元素，存放在序列的起始位置， 表示该位置被排序过了。
②. 然后再从剩余的未排序元素中寻找到最小元素，然后放到已排序的序列的末尾。

代码实现思路： 使用嵌套 for循环实现

外层循环： 从 0 开始 到 数组长度 -1次， 当前代码也就是 i = 0、1、2、3、4 ， 下标从因为从 0 开始 也就是 5 次
内层循环： 第一次循环循环 j < 6 也就是 5 次， 最后一次 j < 6 也就是 1 次
循环体： 内层循环每轮把未排序的第一个数字minValueIndex 和 其后面每一个数字 j 比较， 结束内层循环得到最小值的索引。 外层循环每轮把最小值和未排序的第一个数字交换

// 将成绩从低到高排序
int[] scores = {77, 43, 34, 88, 90, 100};
int temp = 0;
// 外层循环遍历 数组长度-1次
for (int i = 0; i < scores.length - 1; i++) {
    // 内层循环每次拿从第一个开始， 每轮下标 +1， 到最后一个元素
    int minValueIndex = i;
    for (int j = i + 1; j < scores.length; j++) {
        if (scores[minValueIndex] > scores[j]) {
            minValueIndex = j;
        }
    }
    // 一轮结束， index 不是第一个数表示有比他小的，交换
    if (minValueIndex != i) {        
        temp = scores[minValueIndex];
        scores[minValueIndex] = scores[i];
        scores[i] = temp;
    }
}
System.out.println(Arrays.toString(scores));

[34, 43, 77, 88, 90, 100]

二分法查找

二分查找： 也叫折半查找，每次都把数据折半查找， 数据量越大效率越高，但是数据需要先排好顺序。
①. 首先，从数组的中间元素开始搜索，如果该元素正好是目标元素，则搜索过程结束，否则执行下一步。
②. 如果目标元素 大于 或 小于 中间元素，则通过修改 起始索引 或 结束索引 从而在数组 大于 或 小于 中间元素的那一半区域查找。
③. 每次折去一半，直到 起始索引 和 结束索引 下标一致，如果还不是要找的数字， 表示该数组中没有该数字。

// 1. 静态初始化
int[] arr = new int[]{23, 43, 97, 100, 340, 500, 899, 1000, 3000};
Scanner scanner = new Scanner(System.in);
// 要查找的数字
int num = 1000;
int left = 0;
int right = arr.length - 1;
int index = -1;
int middle = 0;
while (left <= right) {
    middle = (left + right) / 2;
    if (arr[middle] == num) {
        index = middle;
        break;
    }else if(num > arr[middle]){
        left = (middle+1);
    }else {
        right -= (middle+1);
    }
}

if(index != -1)
    System.out.println("找到了位置是： " + index);
else
    System.out.println("数组中没有该元素");

五、二维数组

二维数组： 本质上就是元素为一维数组的一个数组

• 静态初始化

  // 静态初始化（不规则二维表） 
  int[][] nums = new int[][]{{1, 3, 44}, {2, 3}, {123}};
  // 静态初始化（规则二维表） 
  int[][] numss = {{1, 3, 44}, {2, 3, 37}, {123, 23, 119}};		
  

• 动态初始化（规则二维表）

  规则二维表： 每一行的列数是相同的

  	// 动态二维数组
      int[][] nums2;
      nums2 = new int[3][3];
      int[][] nums3 = new int[3][3];
  

• 动态初始化（不规则二维表）

  不规则二维表： 每一行的列数不一样

  	int[][] nums4 = new int[3][3];
      nums4[0] = new int[]{43, 43, 43};
      nums4[1] = new int[]{98, 66};
      nums4[2] = new int[]{432, 439};
  

• 赋值、取值

  	int[][] nums = new int[][]{{1, 3, 44}, {2, 3}, {123}};
      // 赋值 把 3 改成 11
      nums[0][1] = 11;
      // 取值 num = 11
      int num = nums[0][1];
  

• 二维数组的遍历

  	int[][] nums = new int[][]{{1, 3, 44}, {2, 3}, {123}};
      // 赋值
      nums[0][1] = 11;
      // 取值
      int num = nums[0][1];
      
      // 遍历二维数组
      for (int i = 0; i < nums.length; i++) {
          for (int j = 0; j < nums[i].length; j++) {
              System.out.print(nums[i][j]  + " ");
          }
          System.out.println();
      }
  

  1 11 44 
  2 3 
  123