数组的定义与使用（2）-CSDN博客

本文链接：https://blog.csdn.net/qq_65784082/article/details/129967589

1. 数组是引用类型

1.1 初始JVM的内存分布

内存是一段连续的存储空间，主要用

来存储程序运行时数据的。比如：

程序运行时代码需要加载到内存
程序运行产生的中间数据要存放在内存
程序中的常量也要保存
有些数据可能需要长时间存储，而有些数据当方法运行结束后就要被销毁

如果对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。比如：

因此JVM也对所使用的内存按照功能的不同进行了划分：

程序计数器 (PC Register)：只是一个很小的空间, 保存下一条执行的指令的地址
虚拟机栈(JVM Stack)：与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
本地方法栈(Native Method Stack)：本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量。在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的
堆(Heap)：JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
方法区(Method Area)：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。方法编译出的的字节码就是保存在这个区域。

现在我们只简单关心堆和虚拟机栈这两块空间，后序JVM中还会更详细介绍。

1.2 基本类型变量与引用类型变量的区别

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。

public static void func() {
  int a = 10;
  int b = 20;
  int[] arr = new int[]{1,2,3};
}

在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。
a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。

从上图可以看到，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单。

1.3 再谈引用变量

public static void func() {
  int[] array1 = new int[3];
  array1[0] = 10;
  array1[1] = 20;
  array1[2] = 30;

  int[] array2 = new int[]{1,2,3,4,5};
  array2[0] = 100;
  array2[1] = 200;

  array1 = array2;
  array1[2] = 300;
  array1[3] = 400;
  array2[4] = 500;
  for (int i = 0; i < array2.length; i++) {
   System.out.println(array2[i]);
 }
}

1.4 认识 null

null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用。

int[] arr = null;
System.out.println(arr[0]);

// 执行结果
Exception in thread "main" java.lang.NullPointerException
at Test.main(Test.java:6)

null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作。一旦尝试读写, 就会抛出 NullPointerException。

注意：Java 中并没有约定 null 和 0 号地址的内存有任何关联。

2.数组练习

2.1求数组中元素的平均值

给定一个整型数组, 求平均值

public static void main(String[] args) {
  int[] arr = {1,2,3,4,5,6};
  System.out.println(avg(arr));
}

public static double avg(int[] arr) {
  int sum = 0;
  for (int x : arr) {
    sum += x;
 }
  return (double)sum / (double)arr.length;
}


// 执行结果
3.5

2.2 查找数组中指定元素(顺序查找)

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置。

public static void main(String[] args) {
  int[] arr = {1,2,3,10,5,6};
  System.out.println(find(arr, 10));
}

public static int find(int[] arr, int data) {
  for (int i = 0; i < arr.length; i++) {
    if (arr[i] == data) {
      return i;
   }
 }
  return -1;  // 表示没有找到
}


// 执行结果
3

2.3 查找数组中指定元素(二分查找)

针对有序数组, 可以使用更高效的二分查找。
什么叫有序数组?

有序分为 "升序" 和 "降序"
如 1 2 3 4 , 依次递增即为升序。
如 4 3 2 1 , 依次递减即为降序。

以升序

数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：

如果相等，即找到了返回该元素在数组中的下标
如果小于，以类似方式到数组左半侧查找
如果大于，以类似方式到数组右半侧查找

public static void main(String[] args) {
  int[] arr = {1,2,3,4,5,6};
  System.out.println(binarySearch(arr, 6));
}

public static int binarySearch(int[] arr, int toFind) {
  int left = 0;
  int right = arr.length - 1;
  while (left <= right) {
 int mid = (left + right) / 2;
    if (toFind < arr[mid]) {
      // 去左侧区间找
      right = mid - 1;
   } else if (toFind > arr[mid]) {
      // 去右侧区间找
      left = mid + 1;
   } else {
      // 相等, 说明找到了
      return mid;
   }
 }
  // 循环结束, 说明没找到
  return -1;
}


// 执行结果
5

可以看到, 针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数越多, 二分的优势就越大。

2.4 数组排序(冒泡排序)

给定一个数组, 让数组升序 (降序) 排序。

算法思路
假设排升序：

将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
依次从上上述过程，直到数组中所有的元素都排列好

public static void main(String[] args) {
  int[] arr = {9, 5, 2, 7};
  bubbleSort(arr);
  System.out.println(Arrays.toString(arr));
}

public static void bubbleSort(int[] arr) {
  for (int i = 0; i < arr.length; i++) {
    for (int j = 1; j < arr.length-i; j++) {
      if (arr[j-1] > arr[j]) {
        int tmp = arr[j - 1];
        arr[j - 1] = arr[j];
        arr[j] = tmp;
     }
   }
 } // end for
}  // end bubbleSort


// 执行结果
[2, 5, 7, 9]

冒泡排序性能较低，Java 中内置了更高效的排序算法

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

关于 Arrays.sort 的具体实现算法, 我们在后面的排序算法课上再详细介绍. 到时候我们会介绍很多种常见排序算法。

Java当中的数组其实就是一个对象

所以我们Java当中一切皆对象

3.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。

基本语法

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

//二维数组:
public static void main11(String[] args) {
    int[][] array = {{1,2,3},{4,5,6}};
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            System.out.print(array[i][j] + " ");
        }
        System.out.println();
    }
    System.out.println("——————————");
    int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
    int[][] array3 = new int[2][3];

二维数组的用法和一维数组并没有明显差别。

在C语言中：二维数组是特殊的一维数组！！！

Java里面把这句话诠释的非常好！！！