JavaSE - 03 数组

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

1.数组

1.1 数组的概述

概述： 在空间中开辟一个连续具有相同数据类型的空间。

数组的特点：

①、数组一旦创建，其长度就不可更改

②、创建数组时，就会在内存中开辟一个连续的空间

③、数组的存取速度快，因为他的存取是根据下标来操作的。

数组的分类：

①、根据维度分：一维数组、二维数组…

②、根据类型分：基本数据类型数组、引用类型数组

1.2 一维数组

一维数组的定义格式：

①、动态初始化数组：数据类型[] 数组名 = new 数据类型[数组长度];

②、静态初始化数组：

数据类型[] 数组名 = {值1,值2,...,值n};

数据类型[] 数组名 = new 数据类型[]{值1,值2,...,值n}

class Demo01{
    public static main(String[] args){
        // 动态初始化数组 : 数据类型[] 数组名 = new 数据类型[数组长度]
        int[] arr = new int[10]; // 初始化了一个长度为10的数组
        
        // 静态初始化数组 : 数据类型[] 数组名 = {值1,值2,...,值n};
        int[] arr2 = {1 , 2 ,3};
        
        // 数据类型[] 数组名 = new 数据类型[]{值1,值2,...,值n}
        int[] arr2 = new int[]{1 , 2 , 3};
    }
}

一维数组的访问：

索引：数组会中默认自动为每一个元素进行编号，这个编号就称为索引（也叫下标）。

访问数组的方式：数组名[下标]

给数组上某个元素设置值:数组名[下标] = 值

class Demo02{
    public static main(String[] args){
        // 声明一个数组
        int[] arr = {1,2,3};
        
        // 获取数组的元素 数组名[下标/索引]
        System.out.println("arr[0] = " + arr[0]); // arr[0] = 1
        System.out.println("arr[1] = " + arr[1]); // arr[1] = 2
        System.out.println("arr[2] = " + arr[2]); // arr[2] = 3
        
        // 给数组元素设置值 数组名[下标] = 值
        arr[2] = 6;
        System.out.println("arr[2] = " + arr[2]); // arr[2] = 6;
    }
}

一维数组内存分析图：

一维数组的使用：

数组的长度：数组名.length

数组下标的取值范围:0 ~ 数组名.length - 1

public class Demo03 {
    public static void main(String[] args) {
        // 创建数组
        int[] arr = {1 , 2 ,3};
        
        // 打印数组的长度
        System.out.println("arr.length = " + arr.length); // 3
    }
}

一维数组的遍历方默认值：

数组元素类型 						  默认初始化值
整数类型：byte,short,int,long 		0
浮点类型：float,double  				0.0
布尔类型：boolean 					false
字符类型：char 						一个空字符，即'\u0000'
引用数据类型 						    null，表示变量不引用任何对象

一维数组的遍历方式：

public class Demo02 {
    public static void main(String[] args) {
        // 创建数组
        int[] arr = {1 , 2 , 3 , 4};

        // 遍历数组方式一：
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr[" + i + "] = " + arr[i]);
        }

        // 遍历方式二：
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

1.3 数组常见的异常

ArrayIndexOutOfBoundsException (数组索引越界异常): 因为访问者访问了一个数组中不存在的索引导致的

public class Demo01 {
    public static void main(String[] args) {
        // 数组索引/下标越界异常
        int[] arr = {1 , 2 , 3};
        // arr中的索引:0 1 2 
        // 4不是arr中的索引，所以程序在数组中找不到4索引，
        //就会报出ArrayIndexOutOfBoundsException异常
        System.out.println("arr[4] = " + arr[4]);

        /**
         * Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
         * 	at com.array.b_arrexception.Demo01.main(Demo01.java:10)
         */
    }
}

NullPointerException（空指针异常） 当数组引用赋值为null,再去调用数组中的元素就会出现空指针异常

public class Demo02 {
    public static void main(String[] args) {
        int[] arr = new int[5]; //0x0011
        arr = null;
        System.out.println(arr[0]);
        /**
         * 当数组引用赋值为null,再去调用数组中的元素就会出现空指针异常
         * Exception in thread "main" java.lang.NullPointerException
         * 	at com.array.b_arrexception.Demo02.main(Demo02.java:11)
         */
    }
}

1.4 二维数组

定义格式:

方式一：数据类型[][] 数组名 = new 数据类型[长度][长度];

方式二：数据类型[][] 变量名 = new 数据类型[长度][];

方式三：数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

使用方式：数组名[m][n] = 值

遍历格式：

for(int i = 0; i < 数组名.length; i++){
	for(int j = 0; j < 数组名[i].length; j++){
		System.out.println(数组名[i][j]);
	}
}

​

2.相关算法

2.1 数组的反转

实现思想： 数组对称位置的元素互换。

如: 原数组元素为:11,22,33,44,55 反转后,数组元素为:55,44,33,22,11

public class Demo01 {
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};

        int temp = 0;
        for (int i = 0; i < arr.length / 2 ; i++){
            temp = arr[i];
            arr[i] = arr[arr.length- 1 - i];
            arr[arr.length - 1 - i] = temp;
        }

        System.out.println(Arrays.toString(arr));
    }
}

2.2 冒泡排序

思路： 相邻元素两两比较，大的往后放第一次完毕，最大值出现在了最大索引处

本质: 通过比较做排序
①、比较的次数 双重for 循环 (外循环决定比较多少轮,内循环决定每轮比较多少次)
②、谁 和谁比较 相邻的两个元素 for(变量 外循环 I 内循环 j ) arr[i] arr[j]
③、如何比较 前> 后 交换 arr[j] > arr[j + 1]

public class Demo02 {
    public static void main(String[] args) {
        int[] arr = {12 , 5 , 3 , 22 ,68};

        // 排序
        int temp = 0; // 第三方变量

        for (int i = 0; i < arr.length -1; i++) { // 外曾循环比较几轮
            for (int j = 0; j < arr.length - 1 - i; j++){ // 内存循环比较几次
                if(arr[j] > arr[j + 1]){ //交换条件 前 > 后
                    // 采用第方变量的方式进行交换
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        System.out.println("arr = " + Arrays.toString(arr));
    }
}

2.3 选择排序

思路： 用索引上的元素依次与其他元素进行比较

public class Demo03 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 4, 5, 6};

        for (int i = 0; i < arr.length - 1; i++) { // 外层循环 控制执行几轮
            for (int j = i + 1; j < arr.length; j++) { //内层循环 控制每轮执行多少次
                if (arr[i] > arr[j]) {   //交换条件  前 > 后
                    // 交换方式 通过第方变量方式进行交换
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("arr = " + Arrays.toString(arr));
    }
}

2.4 遍历查找

思想： 将数组从头到尾依次遍历进行查找

public class Demo01 {
    public static void main(String[] args) {
        int[] arr = {1 , 3 , 5 ,7};
        int num = 5;
        System.out.println(findNum(arr, num));
    }

    // 定义一个查找的方法，找到返回下标，未找到返回-1
    private static int findNum(int[] arr, int num) {
        for (int i = 0; i < arr.length; i++) {
            // 找到输出下标
            if (arr[i] == num ){
                return i;
            }
        }
        return -1;
    }
    
}

2.5 二分法查找（折半查找）

原理： 与中间索引值做比较 ，改变最大索引值，最小索引值，改变查找范围，
Min代表最小值的索引，max代表最大值的引，mid代表需要查找的值的索引
前提：数组元素序

public class Demo02 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7};
        int num = 5;
        System.out.println(binarySearch(arr, num));
    }
    
    private static int binarySearch(int[] arr, int num) {
        int max = arr.length - 1;
        int min = 0;
        int mid = (max + min) / 2;

        while (arr[mid] != num) {

            if (min > max) {
                return -1;
            }

            if (arr[mid] < num) {
                min = mid + 1;
            } else {
                max = mid - 1;
            }
            mid = (max + min) / 2;
        }
        return mid;
    }
}