【Java进阶篇】第二章 Java数组(下篇) 二维数组

1、二维数组

二维数组是一个特殊的一维数组，特殊在这个一维数组当中的每一个元素都是一维数组

System.out.println(a.length); //二维数组的长度

//第一个一维数组元素的长度
System.out.println(a[0].length);
1
2
3
4

2、二维数组元素的读和改

1）读

//二维数组的每个元素都是一个一维数组
int[] a1 = a[0];

//拿一维数组元素中的值
int b = a[0][0]
1
2
3
4
5

2）改

int[][] a = {
                {100,200,300},
                {30,20,40,50,60},
                {6,7,9,1,},
                {0}
        };
a[2][0] = 9527;
a[10][10] = 49; //error
1
2
3
4
5
6
7
8

数组中的下标越界异常–ArrayIndexOutOfBoundException

3、二维数组的遍历

二维数组------for遍历---->一维数组------for遍历---->一维数组中的元素

public class Array1 {
    public static void main(String[] args) {
        int[][] a = {
                {100,200,300},
                {30,20,40,50,60},
                {6,7,9,1,},
                {0}
        };
    for(int i=0;i<a.length;i++){
        for(int k=0;k<a[i].length;k++){
            System.out.println(a[i][k]);
        }
        //每一个一维数组循环结束就空一行
        System.out.println();
    }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//遍历一个动态创建的数组
public class Array1 {
    public static void main(String[] args) {
    	//三个一维数组，每个一维数组中有四个元素
        int[][] array = new int[3][4];
        
    for(int i=0;i<array.length;i++){
        for(int k=0;k<array[i].length;k++){
            System.out.print(array[i][k]);
        }
        System.out.println();
    }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果：

例：

//使用一维数组，模拟栈数据结构
//要求这个栈可以存储Java中的任何引用数据类型
//栈中提供push方法模拟压栈，提供pop方法模拟弹栈

------------------
public class MyStack {
    private Object[] elements;
    private int index;

    /**
     * 在构造方法中赋初值
     * 初始化一维数组的长度为10
     * 使用index模拟栈帧
     */
    public MyStack(){
        this.elements = new Object[10];
        this.index = -1;
    }

    /**
     * 压栈
     * @param obj
     */
    public void push(Object obj){
        if(this.index >= this.elements.length-1){
            System.out.println("压栈失败，栈满");
        }
        this.index++;
        this.elements[index] = obj;
        System.out.println("压栈"+obj+"成功，栈帧指向"+ index);
    }

    /**
     * 弹栈方法
     */
    public void pop(){
        if(index < 0){
            System.out.println("弹栈失败，栈已空");
            return;
        }
        //能到这儿说明栈不空
        System.out.println("弹栈成功，弹出元素："+ elements[index]);
        index--;
    }
}
class Test{
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.push("A String");
        myStack.push(666);
        myStack.push(false);
        myStack.pop();
        myStack.pop();
        myStack.pop();
        myStack.pop();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

思路：
用index属性模拟栈帧指向，和数组的下标做对比。

运行结果：

4、数组工具类原理（java.util.Arrays)

冒泡排序算法BubbleSort

原理图示：

代码实现：

public static void bubbleSort(int[] intArray){
        for(int i=intArray.length-1; i>0; i--){
            for(int k = 0;k < i;k++){
                int temp;
                if(intArray[k] > intArray[k+1]){
                    temp = intArray[k];
                    intArray[k] = intArray[k+1];
                    intArray[k+1] = temp;
                }
            }
        }
        //遍历输出最终结果
        for(int i=0;i<=intArray.length-1;i++){
            System.out.println(intArray[i]);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二分法查找 :

代码实现：

public static void halfSearch(int[] array,int searchValue){
        //开始下标
        int begin = 0;
        //结束下标
        int end = array.length-1;
        while(begin<=end){
            int mid = (begin+end)/2;
            if(array[mid] == searchValue){
                System.out.println("找到了"+array[mid]+"下标为"+mid);
                return;
            }else if(array[mid] < searchValue){
                //在中间元素右侧
                begin = mid+1;
            }else{
                //在中间元素左侧
                end = mid-1;
            }
        }
        //begin>end了还没找到，即不存在
        System.out.println("元素不存在");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5、Array工具类的使用

import java.util.Arrays;
public class Array3 {
    public static void main(String[] args) {
        int[] array = {3,6,5,12,1,2,32,5,5};
        Arrays.sort(array);
        int index = Arrays.binarySearch(array,32);
        System.out.println(index == -1 ? "元素不存在！" : "已找到，元素下标是："+index);
    }
}


1
2
3
4
5
6
7
8
9
10
11

注意：

Arrays.sort(arry)；方法即已将array数组排序好并再次赋给arry了，不用拿新的数组变量再去接收。array这时可直接遍历，也可直接传给binarySearch方法了