Java 基础之数组

清疚 2023-09-29 18:28 19阅读 0赞

数组就是存储数据长度固定的容器，**元素类型必须一致，且长度一旦指定不可更改**，数组是引用数据类型

## 1. 数组定义和访问 ##

int[] arr = new int[3];	// 定义长度为 3可以存放整数的数组
    int[] arr = new int[]{
        1, 2, 3, 4, 5, 6};	// 指定初始值
    int[] arr = {
        1, 2, 3, 4, 5};

**数组访问**

// 使用索引即可访问，从 0 开始
    int[] arr = {
        1, 2, 3, 4, 5};
    arr[0]
    arr[arr.length - 1] // 最后一个元素
    arr[1] = 6  // 赋值

**数组复制**

数组在内存中存储是一块连续内存的空间，如果将一个数组的引用赋值给另一个数组，那么修改复制数组，被复制数组值也会改变：

int[] arr1 = {
        1, 2, 3};
    
    int[] arr4 = arr1;
    arr4[1] = 6;
    System.out.println(arr1[1]);	// 6

## 2. 数组操作 ##

### 2.1 数组越界及空指针异常 ###

int[] arr1 = {
        1, 2, 3};	
    arr1[3]		// 超出数组索引长度将引发数组越界，报 ArrayIndexOutOfBoundsException 错误
    
    arr1 = null
    System.out.println(arr1[1]);	// 空指针异常

### 2.2 数组遍历 ###

*  `for` 循环：可以获取数组索引
 *  `for each` ：无法获取数组索引
 *  `Arrays.toString()` 方法

// for 循环
    int[] arr1 = {
        90, 92, 95, 97, 99};
    for (int i = 0; i < arr1.length; i++) {
        
        System.out.println(arr1[i]);
    }
    
    // for each
    for (int n : arr1) {
        
        System.out.println(n);
    }
    
    // Arrays.toString() 方法
    System.out.println(Arrays.toString(arr1));	// [90, 92, 95, 97, 99]

## 3. 数组排序 ##

**冒泡排序**

特点：每一轮循环后，最大的一个数被交换到末尾（升序排序）：

import java.util.Arrays;
    
    public class ArrayTest {
        
        public static void main(String[] args) {
        
            // 冒泡排序
            int[] ns = {
        28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
            System.out.println(Arrays.toString(ns));
    		
            for (int i = 0; i < ns.length; i++) {
        
                for (int j = 0; j < ns.length - i - 1; j++) {
        
                    // 如果前一个数比后一个数大，两者则进行交换
                    if (ns[j] > ns[j + 1]) {
        
                        
                        // 借助（临时）变量进行交换，Java string 为引用类型，不能直接进行交换
                        int temp = ns[j];
                        ns[j] = ns[j + 1];
                        ns[j + 1] = temp;
                    }
                }
            }
    
            System.out.println(Arrays.toString(ns));    // [8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
        }
    }

--------------------

**Java 内置排序方法**

*  `JDK Arrays.sort()` 方法
 *  对数组排序实际上修改了数组本身

// Arrays.sort(ns) 排序
    int[] ns = {
        28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
    Arrays.sort(ns);
    System.out.println(Arrays.toString(ns));    // 默认升序排序

--------------------

**冒泡排序降序排序**

// 冒泡排序（降序排序）
    int[] ns = {
        28, 12, 89, 73, 65, 18, 96, 50, 8, 36};
    System.out.println(Arrays.toString(ns));
    for (int i = 0; i < ns.length; i++) {
        
        for (int j = 0; j < ns.length - i - 1; j++) {
        
            if (ns[j + 1] > ns[j]) {
        
                int temp = ns[j + 1];
                ns[j + 1] = ns[j];
                ns[j] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(ns));

## 4. 多维数组 ##

### 4.1 二维数组 ###

二维数组在内存中的结构：

┌───┬───┬───┬───┐
             ┌───┐  ┌──>│ 1 │ 2 │ 3 │ 4 │
    ns ─────>│░░░│──┘   └───┴───┴───┴───┘
             ├───┤      ┌───┬───┬───┬───┐
             │░░░│─────>│ 5 │ 6 │ 7 │ 8 │
             ├───┤      └───┴───┴───┴───┘
             │░░░│──┐   ┌───┬───┬───┬───┐
             └───┘  └──>│ 9 │10 │11 │12 │
                        └───┴───┴───┴───┘

二维数组操作：

// 二维数组
    int[][] ns = {
        
        {
        1, 2, 3, 4},
        {
        5, 6, 7, 8},
        {
        9, 10, 11, 12}
    };
    int[] n1 = ns[0];
    System.out.println(Arrays.toString(n1));    // [1, 2, 3, 4]
    System.out.println(ns.length);      // 3
    System.out.println(ns[1][1]);   // 访问二维数组   6

二维数组打印：

*  两层 `for` 循环
 *  `Arrays.deepToString()` 方法

// 遍历循环
    for (int[] n : ns) {
        
        for (int m : n) {
        
            System.out.println(m);
        }
    }
    
    // Arrays.deepToString()
    System.out.println(Arrays.deepToString(ns));	// [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

### 4.2 三维数组 ###

一般而已用的比较多的就是二维数组，三维数组及以上就用的比较少了：

// 三维数组
    int[][][] ns = {
        
        {
        
            {
        1, 2, 3},
            {
        4, 5, 6}
        },
        {
        
            {
        1, 2},
            {
        2, 5}
        },
        {
        
            {
        3, 4},
            {
        6, 8}
        }
    };
    
    //[[[1, 2, 3], [4, 5, 6]], [[1, 2], [2, 5]], [[3, 4], [6, 8]]]
    System.out.println(Arrays.deepToString(ns));
    System.out.println(ns[0][1][1]);    // 访问 5

## 5. 数组作为参数和返回值 ##

与基本数据类型一直，数组也可以作为参数传递给函数使用或者作为返回值返回：

public static void main(String[] args) {
        
        int[] arr = {
        1, 2, 3};
        printArr(arr);
        
        int[] arr1 = getArr();
    }
    public static void printArr(int[] arr) {
        
        for (int n: arr) {
        
            System.out.println(n);
        }
    }
    
    public static int[] getArr() {
        
        int[] arr = {
        1, 2, 3};
        return arr;
    }

## 6. 命令行参数 ##

`Java main()` 方法可以接收一个 `String []` 数组命令行参数：

public class CmdArgTest {
        
        public static void main(String[] args) {
        
            for (String arg: args) {
        
                System.out.println(arg);
    			
                // 当输入的是 -version 参数时，输出当前 java 版本号
                if ("-version".equals(arg)) {
        
                    System.out.println("java v1.0");
                    break;
                }
            }
        }
    }

编译传入参数：

F:\JavaStudy\Source\Hello World>javac CmdArgTest.java
    
    F:\JavaStudy\Source\Hello World>java CmdArgTest -version
    -version
    java v1.0