开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 【JavaSE】----- 数组的定义与使用 -> 正文阅读

[Java知识库]【JavaSE】----- 数组的定义与使用

一、数组的基本用法

🍎什么是数组

数组本质上就是让我们能 "批量" 创建相同类型的变量。

🍓数组：存储一组相同数据类型的集合。

💦例如:

如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b
如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建.

💥注意事项: 在 Java 中, 数组中包含的变量必须是相同类型。

🍎创建数组

?基本语法

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };

// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };

🌊代码示例：

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = new int[3]; //创建一个数组未初始化
        int[] arr1 = new int[]{1, 2, 3}; //创建数组并初始化
        int[] arr2 = {1, 2, 3}; //虽然没写new，实际上也是一个对象
    }

}

💥注意事项:

静态初始化的时候, 数组元素个数和初始化数据的格式是一致的.
int [] 数组名，[ ]中不可以指定大小，因为 int 和 [ ] 是一个整体，表示它是一个整型的数组，int [ ] 是一个类型，如果字 [ ]中写了一个数字就会破坏它的类型。

💧补充：

其实数组也可以写成：int arr[] = {1, 2, 3}; 这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. int和 [] 是一个整体.

🍎数组的使用

🍓获取长度，访问元素。

🌊代码示例：

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println("length = " + arr.length);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        arr[2] = 100;
        System.out.println(arr[2]);
    }

}

运行结果

💥注意事项

使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
使用 [ ] 操作既能读取数据, 也能修改数据.
下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。

🍓数组越界访问

🌊代码示例：

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

🍓遍历数组

Java中遍历数组有三种方式：for循环、for-each、Java的操作数组的工具类 Arrays。

🌊代码示例：使用for循环遍历数组

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

}

🌊代码示例：使用 for-each（增强for循环）遍历数组

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        for (int x : arr) {
            System.out.print(x + " ");
        }
    }

}

运行结果

for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历。可以避免循环条件和更新语句写错。

?for循环与 for-each 的区别：

for循环是可以拿到数组下标的
for-each 是拿不到数组下标的

🌊代码示例：借助Java的操作数组的工具类 Arrays

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //Arrays.toString 是将参数的数组以字符串的形式输出
        String ret = Arrays.toString(arr);
        System.out.println(ret);
        // System.out.println(Arrays.toString(arr));
    }

}

?运行结果

👀Java 中提供了 java.util.Arrays 包, 其中包含了一些操作数组的常用方法

💦补充：什么是包?

例如做一碗油泼面, 需要先和面, 擀面, 扯出面条, 再烧水, 下锅煮熟, 放调料, 泼油.
但是其中的 "和面, 擀面, 扯出面条" 环节难度比较大, 不是所有人都能很容易做好. 于是超市就提供了一些直接已经扯好的面条, 可以直接买回来下锅煮. 从而降低了做油泼面的难度, 也提高了制作效率.
程序开发也不是从零开始, 而是要站在巨人的肩膀上.
很多程序写的过程中不必把所有的细节都自己实现, 已经有大量的标准库(JDK提供好的代码)和海量的第三方库(其他机构组织提供的代码)供我们直接使用. 这些代码就放在一个一个的 "包" 之中. 所谓的包就相当于卖面条的超市. 只不过, 超市的面条只有寥寥几种, 而我们可以使用的 "包" , 有成千上万。

二、数组作为方法的参数

🍎数组传参

🌊代码示例

import java.util.Arrays;

public class TestDemo {
    public static void func1(int[] arr) {
        arr[0] = 66;
    }

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

?代码分析

运行结果

🌌 数组传参在函数内部修改数组内容, 函数外部也发生改变.此时数组名 arr 是一个 "引用"。当传参的时候, 是按照引用传参。?

🌊代码示例

import java.util.Arrays;

public class TestDemo {
    public static void func2(int[] arr) {
        arr = new int[]{21, 23, 25, 24, 26};
    }

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

}

代码分析

运行结果

这里的内容没被修改是因为在func2方法中重新创建了一个arr数组，此时func2方法中的数组与实参传过去的数组在堆区指向的是两块不同的空间。
在func2中只是创建了新的数组，并没有改变main方法中传过去的数组，所以func2方法（函数）外部没有发生变化。

💦补充：如何理解内存?

内存就是指我们熟悉的 "内存". 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间.
每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿个这样的房间).
每个房间上面又有一个门牌号, 这个门牌号就称为地址。

🍓什么是引用?

引用相当于一个 "别名", 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址。

?总结:

所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)。

🍎认识 null

?null 在 Java 中表示 "空引用" , 也就是一个无效的引用

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

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

内容总结：

🍎初识 JVM 内存区域划分

一个宿舍楼会划分成几个不同的区域: 大一学生, 大二学生... 计算机专业学生, 通信专业学生....内存也是类似, 这个大走廊被分成很多部分, 每个区域存放不同的数据.

🎄JVM 的内存被划分成了几个区域,

程序计数器 : 只是一个很小的空间, 保存下一条执行的指令的地址.
虚拟机栈（Java栈）: 重点是存储局部变量表(当然也有其他信息). 刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.
本地方法栈：本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.
堆：JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3,4,5} )
方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.
运行时常量池：是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意从 JDK1.7 开始, 运行时常量池在堆上)。

🍉本地方法栈：

JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操
作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数

🍉了解栈和堆：

局部变量和引用保存在栈上, new 出的对象保存在堆上.
堆的空间非常大, 栈的空间比较小.
堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈)。

三、数组作为方法的返回值

🌊代码示例：写一个方法, 将数组中的每个元素都 * 2。

import java.util.Arrays;

public class TestDemo {
    public static void fun(int[] arr1) {
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr1[i] * 2;
        }
    }

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

代码分析

运行结果

这个代码虽然可行, 但是破坏了原有数组。
有时候不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回。

🌊代码示例

import java.util.Arrays;

public class TestDemo {
    public static int[] fun1(int[] arr1) {
        int[] ret = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++) {
            ret[i] = arr1[i] * 2;
        }
        return ret;
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3, 4, 5, 6};
        int[] ret = fun1(arr1);
        System.out.println(Arrays.toString(ret));
        System.out.println(Arrays.toString(arr1));
    }
}

代码分析

运行结果

这种方式不会破坏原有数组，另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效。

四、数组练习

🎄 模拟实现toString方法

public class TestDemo {
    public static String myToString(int[] array) {
        if (array == null) return "null";
        String str = "[ ";
        for (int i = 0; i < array.length; i++) {
            str += array[i];
            if (i != array.length - 1) {
                str += ",";
            }
        }
        str += " ]";
        return str;
    }

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

}

运行结果

🎄 找数组中的最大元素

public class TestDemo {
    public static int findMax(int[] array) {
        //判断数组如果是没有元素或是null，则返回-1
        if (array == null || array.length == 0) return -1;
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        int[] array = {12, 1, 6, 99, 84, 3};
        System.out.println(findMax(array));
    }
}

🎄 求数组中元素的平均值

public class TestDemo {
    public static double avg(int[] array) {
        if (array == null || array.length == 0) return 0;
        int sum = 0;
        for (int i : array) {
            sum += i;
        }
        return (double) sum / array.length;
    }

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

🎄 查找数组中指定元素(顺序查找)，返回其所在位置的下标

public class TestDemo {
    public static int find(int[] array, int key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return i; //返回找到值的下标
            }
        }
        return -1; //如果没找到就返回-1
    }

    public static void main(String[] args) {
        int[] arr = {14, 15, 16, 3, 8, 2};
        System.out.println(find(arr, 2));
    }
}

🎄查找数组中指定元素(二分查找)，返回其所在位置的下标。

二分查找只能查找有序（升序或降序）的数组。
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找。

public class TestDemo {
    public static int binarySearch(int[] array, int key) {
        int left = 0; //左下标
        int right = array.length - 1; //右下标
        while (left <= right) {
            int mind = (left + right) / 2;
            if (key > array[mind]) {
                left = mind + 1;
            } else if (key < array[mind]) {
                right = mind - 1;
            } else if (key == array[mind]) {
                return mind;
            }
        }
        return -1;
    }

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

}

🎄检查数组的有序性

给定一个整型数组, 判断是否该数组是有序的(升序)

public class TestDemo {
    public static boolean isSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i] > array[i + 1]) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] array = {1, 3, 6, 8, 9};
        System.out.println(isSort(array));
    }

}

🎄冒泡排序

public class TestDemo {
    public static void bubbleSort(int[] array) {
        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] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flag = true;
                }
                if (flag == false) {
                    return;
                }
            }
        }
    }

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

}

🎄数组逆序

public class TestDemo {
    public static void reverse(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int tmp = array[left];
            array[left] = array[right];
            array[right] = tmp;
            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        reverse(array);
        System.out.println(Arrays.toString(array));
    }

}

🎄数组数字排列

给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分

public class TestDemo {
    public static void func(int[] arr) {
        int left = 0;
        int right = arr.length - 1;
        while (left < right) {
            while (left < right && arr[left] % 2 == 0) {
                left++;
            }
            while (left < right && arr[right] % 2 != 0) {
                right--;
            }
            int tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 6, 8, 4, 7};
        func(arr);
        System.out.println(Arrays.toString(arr));
    }
}

🍓数组拷贝

（1）代码1

import java.util.Arrays;

public class TestDemo {
    public static int[] copOf(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = arr[i];
        }
        return ret;
    }

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

（2）代码2?

import java.util.Arrays;

public class TestDemo {
      public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int[] ret = Arrays.copyOf(arr,arr.length);
      System.out.println(Arrays.toString(ret));

    }
 }

（3）代码3 ：拷贝指定位置的元素?

public class TestDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int[] ret =  Arrays.copyOfRange(arr,0,3);// [ )
        System.out.println(Arrays.toString(ret));
    }
}

（4）代码4?

import java.util.Arrays;

public class TestDemo {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int[] copy = new int[arr.length];
        //从arr数组的0位置开始，拷贝到copy数组中，从copy数组的0位置，长度为arr数组的长度
        System.arraycopy(arr,0,copy,0,arr.length);
        System.out.println(Arrays.toString(copy));
    }
}

（5）代码5?

import java.util.Arrays;

public class TestDemo {

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

🍓深拷贝与浅拷贝

深拷贝：创建了一个新的数组, 拷贝原有数组中的所有元素到新数组中（拷贝的是对象【元素】）. 因此, 修改原数组, 不会影响到新数组。
浅拷贝：创建了一个新数组，新数组与原数组都指向同一个对象（拷贝的是地址）。因此，修改原始值，会影响新数组。
浅拷贝变为深拷贝：将原数组指向的对象再拷贝一份，使新数组指向拷贝后的对象。（原数组与新数组指向了不同的对象，修改新数组的内容不会影响原数组）
至于是深拷贝、还是浅拷贝主要看拷贝的内容是什么。

五、二维数组

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

🍎创建二维数组

?基本语法

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

🌊代码示例

public class TestDemo {
    public static void main(String[] args) {
        int[][] array1 = {{1, 2, 3}, {4, 5, 6}};
        int[][] array2 = new int[][]{{1, 2, 3}, {4, 5, 6}};
        int[][] array3 = new int[2][3];
    }

}

内存布局

🍎 遍历二维数组

🌀方法一：

public class TestDemo {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {4, 5, 6}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "  ");
            }
            System.out.println();
        }
    }

}

🌀方法二：

public class TestDemo {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {4, 5, 6}};
        for (int[] ret : array) {
            for (int x : ret) {
                System.out.print(x + "  ");
            }
            System.out.println();
        }
    }
}

🌀方法三：

public class TestDemo {
    public static void main(String[] args) {
        int[][] array = {{1, 2, 3}, {4, 5, 6}};
        System.out.println(Arrays.deepToString(array));
    }

}

运行结果

🍎不规则二维数组

public class TestDemo {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {4, 5, 6}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

运行结果

?Java中定义二维数组时不可以省略行但是可以省略列。

public class TestDemo {

    public static void main(String[] args) {
        int[][] arr = new int[2][];
        arr[0] = new int[2];
        arr[1] = new int[3];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "  ");
            }
            System.out.println();
        }
    }

}

内存布局

运行结果