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

我就是我 2023-10-08 17:11 31阅读 0赞

#### 文章目录 ####

*  1、二维数组
 *  2、二维数组元素的读和改
 *  3、二维数组的遍历
 *  4、数组工具类原理（java.util.Arrays)
 *  5、Array工具类的使用

## 1、二维数组 ##

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

![图][7233e3ae7c244f6a897b96dbd3db351e.png]

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

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

**1）读**

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

**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

**数组中的下标越界异常–ArrayIndexOutOfBoundException**  
![在这里插入图片描述][9052e6f52ede4383b53d9298f7727801.png]

## 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();
        }
        }
    
    }

//遍历一个动态创建的数组
    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();
        }
        }
    
    }

运行结果：  
![在这里插入图片描述][3e5fa2087f3640a9a68f4bbd36921f35.png]

**例：**

//使用一维数组，模拟栈数据结构
    //要求这个栈可以存储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();
        }
    }

思路：  
用index属性模拟栈帧指向，和数组的下标做对比。  
![在这里插入图片描述][8b61e44e7a934a1ba3bcba5cff74478a.png]

运行结果：  
![在这里插入图片描述][8519c25c1abd4746a1dd382f9ba6e654.png]

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

![在这里插入图片描述][da2a59b7b53847f9a941e1b937f9abda.png]

> **冒泡排序算法BubbleSort**

**原理图示：**

![在这里插入图片描述][a99fcdc26e254beea4451ec373bca538.jpeg]

![在这里插入图片描述][a628500f57a94727892205ab4eee4725.jpeg]  
**代码实现：**

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]);
            }
        }

> **二分法查找 :**

![在这里插入图片描述][21a5d1ca63f04faaa72f2faed96d3757.png]  
![在这里插入图片描述][f613b3cad3454638bb7d6cde4d2770c9.png]  
**代码实现：**

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("元素不存在");
        }

## 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);
        }
    }

注意：

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

[7233e3ae7c244f6a897b96dbd3db351e.png]: https://img-blog.csdnimg.cn/7233e3ae7c244f6a897b96dbd3db351e.png
[9052e6f52ede4383b53d9298f7727801.png]: https://img-blog.csdnimg.cn/9052e6f52ede4383b53d9298f7727801.png
[3e5fa2087f3640a9a68f4bbd36921f35.png]: https://img-blog.csdnimg.cn/3e5fa2087f3640a9a68f4bbd36921f35.png
[8b61e44e7a934a1ba3bcba5cff74478a.png]: https://img-blog.csdnimg.cn/8b61e44e7a934a1ba3bcba5cff74478a.png
[8519c25c1abd4746a1dd382f9ba6e654.png]: https://img-blog.csdnimg.cn/8519c25c1abd4746a1dd382f9ba6e654.png
[da2a59b7b53847f9a941e1b937f9abda.png]: https://img-blog.csdnimg.cn/da2a59b7b53847f9a941e1b937f9abda.png
[a99fcdc26e254beea4451ec373bca538.jpeg]: https://img-blog.csdnimg.cn/a99fcdc26e254beea4451ec373bca538.jpeg
[a628500f57a94727892205ab4eee4725.jpeg]: https://img-blog.csdnimg.cn/a628500f57a94727892205ab4eee4725.jpeg
[21a5d1ca63f04faaa72f2faed96d3757.png]: https://img-blog.csdnimg.cn/21a5d1ca63f04faaa72f2faed96d3757.png
[f613b3cad3454638bb7d6cde4d2770c9.png]: https://img-blog.csdnimg.cn/f613b3cad3454638bb7d6cde4d2770c9.png