【Java SE】数组

xxxflower

发布于 2023-04-16 17:34:16

8050

文章被收录于专栏：《数据结构》《数据结构》

1.数组的基本概念

1.1数组的定义

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

注意：

数组中存放的元素其类型相同
数组的空间是连在一起的
每个空间有自己的编号，其实位置的编号为0，即数组的下标。

1.2数组的创建及初始化

1.2.1数组的创建

T[] 数组名 = new T[N];

int[] arr3 = new int[10];//只是分配了内存但是没有进行赋值，只有默认值

1.2.2数组的初始化

动态初始化：在创建数组时，直接指定数组中元素的个数
静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

【注意】： 1.静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。 2.静态初始化时, {}中数据类型必须与[]前数据类型一致。 3.静态初始化可以简写，省去后面的new T[]。 4.静态和动态初始化也可以分为两步，但是省略格式不可以。 5.如果没有对数组进行初始化，数组中元素有其默认值

1.3数组的使用

1.3.1数组中元素的访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。【注意】：

数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常

1.3.2遍历数组

方法一：for循环

方法二：for each（增强for循环）

方法三：把数组转变为字符串，然后返回

注意：使用Arrays.时导入包import java.util.Arrays; 知识拓展：

2.数组是引用类型

2.1初识JVM的内存分布

内存是一段连续的存储空间，主要用来存储程序运行时数据的。

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

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

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

2.3 认识null

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

3.数组传参

3.1例题

3.2例题2

1.数组对象是在堆上的 2.引用变量目前是在main函数里面的，它属于局部变量，当函数结束就会被回收

4.数组的应用

4.1自主实现Arrays.toString（将数组以字符串的方式打印）功能

和C语言中的断言相比，Java中使用断言的情况较少。且使用断言时，需要设置参数，具体见：断言的使用方法

4.2 数组拷贝

拷贝：必须产生新的内空间

方法一：自主实现

方法二：利用Arrays包. Arrays在使用前要说明一下

import java.util.Arrays;

Arrays.copyOf的使用很方便，不仅可以拷贝数组，还可以控制被拷贝数组的大小：

还可以实现部分拷贝：

4.3二分查找

二分查找：二分查找必须要求是顺序数组。 1.利用包进行二分查找

2.自己实现二分查找

public static int myBinarySearch(int [] array,int x){
        int left = 0;
        int right = array.length - 1;
        while(left <= right){
            int mid = (left + right)/2;
            if(x > array[mid]){
                left = mid + 1;
            }else if(x < array[mid]){
                right = mid - 1;
            }else
                return mid;
        }
        return -1;
    }

    public static void main(String[] args) {
        //找到了返回下标，没找到返回-1
        int[] array1 = {1,2,3,4,5,6,7,8};
        int n = myBinarySearch(array1,4);
        System.out.println(n);
    }

【关于Arrays包】的拓展：

Arrays.fill()

4.6 详解冒泡排序

我们可以发现在只有5个数的情况下，将第一个数字排好需要与相邻的数字比较4次，4个数字需要比较3次,3个数字需要比较2次，2个数字需要比较一次。总共需要比较4趟。我们可以写出以下代码：

 public static void main(String[] args) {
        int[] array = {12,6,3,5,1};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) { //外层循环趟数
            for (int j = 0; j < arr.length-1-i; j++) { //内层循环次数
                if(arr[j+1] > arr[j]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
    }

我们可以优化代码：

public class test {
    public static void main(String[] args) {
        int[] array = {12,6,3,5,1};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) { //外层循环趟数
            //检查是否有序
            boolean flg = false;
            for (int j = 0; j < arr.length-1-i; j++) { //内层循环次数
                if(arr[j+1] < arr[j]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    flg = true;
                }
            } if(flg == false){
                return ;
            }
        }
    }