Java基础语法_第9章 数组

9.1 数组的定义

• 数组是相同类型的有序集合
• 数组是按照一定的先后次序排序组合而成的
• 其中每一个数据称作一个数组元素，每个数组元素可以通过下标来访问它们
• 数组的下标从0开始

9.2 数组申明创建

• 首先必须声明数组变量，才能在程序中使用数组

  dataType[] arrayRefVar; // 首选的方法
  dataType arrayRefVar[]; // 是C和C++的语法，效果相同，但不是首选方法
  

• Java语言使用new操作符来创建数组

  dataType[] arrayRefVar = new dataType[arraySize];
  

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

• 获取数组长度：arrays.length （是元素的个数，不是最大下标）

int[] nums; // 声明数组
nums = new int[5]; // 创建一个数组
// 给数组元素赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[4] = 5;
System.out.println(nums[2]); // 3
System.out.println(nums[3]); // 0（int类型的默认值）
System.out.println(nums.length); // 5

9.3 内存分析

Java内存

• 堆
  • 存放new的对象和数组
  • 可以被所有线程共享，不会存放别的对象引用
• 栈
  • 存放基本变量类型（包含这个基本类型的具体值）
  • 引用对象的变量（会存放这个引用在堆里面的具体地址）
• 方法区
  • 可以被所有的线程共享
  • 包含了所有的class和static变量

9.4 数组的特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。如果越界，则会报ArrayIndexOutOfBoundsException

• 其元素必须是相同类型，不允许出现混合类型

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型

• 数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该成员的变量

  数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是引用类型

9.5 数组边界

• 下标的合法区间：[0, length - 1]，如果越界就会报错

  int[] nums = {1, 2, 3, 4, 5};
  for (int i = 0; i <= nums.length; i++) {
      System.out.println(nums[i]);
  }
  

• ArrayIndexOutOfBoundsException：数组下标越界异常

9.6 数组使用

• For-Each循环

  int[] nums = {1, 2, 3, 4, 5};
  // 打印全部的数组元素
  for (int i = 0; i < nums.length; i++) {
      System.out.println(nums[i]);
  }
  
  // 计算所有元素的和
  int sum = 0;
  for (int i = 0; i < nums.length; i++) {
      sum = sum + nums[i];
  }
  System.out.println(sum); // 15
  
  // 查找最大元素
  int max = nums[0];
  for (int i = 0; i < nums.length; i++) {
      if(nums[i] > max) {
  max = nums[i];
      }
  }
  System.out.println(max); // 5
  

• 数组作为方法入参

  public static void main(String[] args) {
      int[] nums = {1, 2, 3, 4, 5};
      printNums(nums);
  }
  
  // 打印数组元素
  public static void printNums(int[] nums) {
      for (int num : nums) {
          System.out.println(num);
      }
  }
  

• 数组作为返回值

  public static void main(String[] args) {
      int[] nums = {1, 2, 3, 4, 5};
      // 先反转数组，再打印数组元素
      printNums(reverse(nums));
  }
  
  // 打印数组元素
  public static void printNums(int[] nums) {
      for (int num : nums) {
          System.out.println(num);
      }
  }
  
  // 反转数组
  public static int[] reverse(int[] nums) {
      int[] reverseNums = new int[nums.length];
      for(int i = 0, j = reverseNums.length - 1; i < nums.length; i++, j--) {
          reverseNums[j] = nums[i];
      }
      return reverseNums;
  }
  

9.7 多维数组

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

• 二维数组：int a[][] = new int[2][5]

  int[][] array = {{1,2}, {2, 3}, {3, 4}, {4, 5}};
  System.out.println(array[2][0]); // 3
  System.out.println(array[2][1]); // 4
  for (int i = 0; i < array.length;i++) {
      for (int j = 0; j < array[i].length; j++) {
          System.out.println(array[i][j]);
      }
  }
  

9.8 Arrays类

• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类java.util.Arrays供我们使用，从而可以对数据对象进行一些基本的操作
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用
• 具有以下常用功能：
  • 给数组赋值：通过fill方法
  • 对数组排序：通过sort方法（升序）
  • 比较数组：通过equals方法比较数组中元素值是否相等
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

int[] array = {3, 1, 4, 2, 5};
System.out.println(Arrays.toString(array)); // [3, 1, 4, 2, 5]
Arrays.sort(array);
System.out.println(Arrays.toString(array)); // [1, 2, 3, 4, 5]
Arrays.fill(array, 7);
System.out.println(Arrays.toString(array)); // [7, 7, 7, 7, 7]
Arrays.fill(array, 2, 4, 0);
System.out.println(Arrays.toString(array)); // [7, 7, 0, 0, 7]

9.9 冒泡排序

public static void main(String[] args) {
    int[] array = {5, 7, 6, 9, 1, 2};
    System.out.println(Arrays.toString(sort(array))); // [9, 7, 6, 5, 2, 1]
}

// 冒泡排序
// 1. 比较数组中两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
// 2. 每一次比较都会产生一个最大，或者最小的数组
// 3. 下一轮则可以少一次排序
// 4. 依次循环，知道结束
public static int[]  sort(int[] array) {
    // 临时变量
    int temp = 0;
    // 外层循环，判断要走多少次
    for(int i = 0; i < array.length - 1; i++) {
        boolean flag = false;
        // 内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j + 1] > array[j]) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                flag = true;
            }
        }
        if (!flag) {
            break;
        }
    }
    return array;
}