零基础学Java第九讲---数组（2）

寻星探路

发布于 2025-12-17 18:49:54

1190

一、数组的应用场景

1、保存数据

public static void main(String[] args) {
    int[] array = {1, 2, 3};

    for(int i = 0; i < array.length; ++i){
        System.out.println(array[i] + " ");
    }
}

2、作为函数的参数

2.1参数传基本数据类型

 public static void main(String[] args) {
     int num = 0;
     func(num);
     System.out.println("num = " + num);
 }

 public static void func(int x) {
     x = 10;
     System.out.println("x = " + x);
 }

 // 执⾏结果 
 x = 10
 num = 0

我们可以发现在func方法中修改形参x的值,不影响实参的num值

2.2参数传数组类型(引用数据类型)

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

 public static void func(int[] a) {
     a[0] = 10;
     System.out.println("a[0] = " + a[0]);
 }

 // 执⾏结果 
 a[0] = 10
 arr[0] = 10

在func方法内部修改数组的内容,方法外部的数组内容也发生改变. 因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的

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

3、作为函数的返回值

如：获取斐波那契数列的前N项

 public class TestArray {
     public static int[] fib(int n){
         if(n <= 0){
             return null;
         }
         int[] array = new int[n];
         array[0] = array[1] = 1;
         for(int i = 2; i < n; ++i){
             array[i] = array[i-1] + array[i-2];
         }
         return array;
     }

     public static void main(String[] args) {
         int[] array = fib(10);
         for (int i = 0; i < array.length; i++) {
             System.out.println(array[i]);
         }
     }
 }

二、操作数据工具类Arrays与数组练习

1、数组转字符串

import java.util.Arrays

int[] arr = {1,2,3,4,5,6};

String newArr = Arrays.toString(arr);
System.out.println(newArr);

// 执⾏结果 
[1, 2, 3, 4, 5, 6]

使用这个方法后续打印数组就更方便⼀些

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

2、数组拷贝

import java.util.Arrays;

public static void func(){
    // newArr和arr引⽤的是同⼀个数组 
    // 因此newArr修改空间中内容之后，arr也可以看到修改的结果 
    int[] arr = {1,2,3,4,5,6};
    int[] newArr = arr;
    newArr[0] = 10;
    System.out.println("newArr: " + Arrays.toString(arr));

    // 使⽤Arrays中copyOf⽅法完成数组的拷⻉： 
    // copyOf⽅法在进⾏数组拷⻉时，创建了⼀个新的数组 
    // arr和newArr引⽤的不是同⼀个数组 
    arr[0] = 1;
    newArr = Arrays.copyOf(arr, arr.length);
    System.out.println("newArr: " + Arrays.toString(newArr));

    // 因为arr修改其引⽤数组中内容时，对newArr没有任何影响 
    arr[0] = 10;
    System.out.println("arr: " + Arrays.toString(arr));
    System.out.println("newArr: " + Arrays.toString(newArr));

    // 拷⻉某个范围. 
    int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
    System.out.println("newArr2: " + Arrays.toString(newArr2));
}

#注：数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类型，拷贝时需要考虑深浅拷贝的问题，关于深浅拷贝在后续详细给⼤家介绍

实现自己的拷贝数组

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

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

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

代码示例：

 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

4、查找数组中指定元素(⼆分查找)

针对有序数组,可以使用更高效的⼆分查找

首先解释一下有序数组：

有序数组分为升序和降序：

如1 2 3 4 ，依次递增为升序；

如4 3 2 1，依次递减为降序。

我们接下来以升序为例，进行一遍二分查找：

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

（1）如果相等，即找到了返回该元素在数组中的下标

（2）如果小于，以类似方式到数组左半侧查找

（3）如果大于，以类似方式到数组右半侧查找

代码示例:

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次就能完成查找.随着数组元素个数越多,⼆分的优势就越大

5、数组排序(冒泡排序)

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

思路（假设排升序）：

（1）将数组中相邻元素从前往后依次进行比较，如果前⼀个元素比后⼀个元素大，则交换，⼀趟下来后最大元素就在数组的末尾

（2）依次重复上述过程，直到数组中所有的元素都排列好

 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 的具体实现算法,我们在后面的数据结构上再详细介绍.到时候我们会介绍很多种常见排序算法

6、数组逆序

给定⼀个数组,将里面的元素逆序排列

逆序思路：

设定两个下标,分别指向第⼀个元素和最后⼀个元素，交换两个位置的元素；然后让前⼀个下标自增,后⼀个下标自减,循环继续即可。

代码示例：

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

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

三、⼆维数组

1、普通的二维数组

⼆维数组本质上也就是⼀维数组,只不过每个元素又是⼀个⼀维数组

基本语法：

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

#注：行不可以省略，列可以省略

代码示例：

 int[][] arr = {
     {1, 2, 3, 4},
     {5, 6, 7, 8},
     {9, 10, 11, 12}
 };

 for (int row = 0; row < arr.length; row++) {
     for (int col = 0; col < arr[row].length; col++) {
         System.out.printf("%d\t", arr[row][col]);
     }
     System.out.println("");
 }

 // 执⾏结果 
 1 2  3  4
 5 6  7  8
 9 10 11 12

（1）⼆维数组是特殊的⼀维数组，⼀维数组的每个元素又是⼀个数组

（2）arr.length 代表⼆维数组的行数

（3）arr[row].length 代表⼆维数组的列数

2、不规则的⼆维数组

不规则的⼆维数组指的是，⼆维数组的列在定义的时候，没有确定。

 int[][] array = new int[2][];
 array[0] = new int[3];
 array[1] = new int[5];

上述⼆维数组就不是⼀个规则的⼆维数组。第1行有3列，第2行有5列。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-11-11，如有侵权请联系 cloudcommunity@tencent.com 删除

基础

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度