java基础之数组的介绍

偏执的太偏执、 2022-06-13 07:40 228阅读 0赞

## 1.数组的定义 ##

*  概念：  
    同一数据类型的数据集合，其实数组就是一个容器。
 *  数组的好处  
    可以自动给数组中的元素从0开始编号，方便操作这些元素。
 *  数组格式：

- 格式1：
    元素类型[] 数组名 = new 元素类型[元素个数或数组长度]
    例如： int[] arr = new int[5];
    - 格式2：
    元素类型[] 数组名 = new 元素类型[] {元素，元素...}
    例如：int [] arr = new int [] {
       1,3,7,5};
    int [] arr = {
       1,3,7,5};

## 2.数组的内存分配及特点 ##

*  内存的划分：  
    寄存器  
    本地方法区  
    方法区  
    栈内存：存儲的都是局部变量，变量所属的作用域一旦结束，该变量就自动释放。  
    堆内存：存储的是数组和对象（数组也是对象），凡是new建立在堆中。特点：1.每一个实体都有首地址值。2.堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数是0，小数是0.0或者0.0f，boolean初始值为false，char初始值为‘\\u0000’，对象初始化值为null。3.垃圾回收機制。  
    ![这里写图片描述][SouthEast]

## 3.数组操作常见问题 ##

数组索引越界异常：当访问到数组中不存在的角标时，就会发生该异常。  
空指针异常：当引用型变量没有任何实体指向时，还在用其操作实体，就会发生该异常  
直接打印数组：会打印（实体类型+@+哈希码值）

## 4.数组常见操作 ##

对数组操作最基本动作就是存和取；核心思想：就是对角标的操作。

*  数组的遍历

public class Demo2 {
        public static void main(String[] args) {
            //数组的遍历
            int[] arr = {
       1,2,5,9,3,10};
            System.out.println(arr);
            for (int i = 0; i < arr.length; i++) {  
                System.out.print(arr[i] +"\t");
            }
        }
    }
    结果：
    [I@15db9742
    1   2   5   9   3   10

*  获取数组中最值

public class Demo3 {
        public static void main(String[] args) {
            int[] arr = {
       1,22,5,9,3,10};
            System.out.println(getMax(arr));
        }
        //定义一个方法求数组中的最大值
        //明确返回值类型：和数组类型相同 参数列表：当前数组
        public static int getMax(int[] arr) {
            int max = 0;
            for (int i = 0; i < arr.length; i++) {
                if(arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        }
    }
    结果：
    22

*  选择排序  
    工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

public class Demo4 {
        public static void main(String[] args) {
            int[] arr = {
       1,22,5,9,3,10};
            array(arr);
            selectSort(arr);
            System.out.println();
            array(arr);
    
        }
        //选择排序
        public static void selectSort(int[] arr) {
            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[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
    
        }
        public static void array(int[] arr) {
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
        }
    }
    结果：
    1   22  5   9   3   10  
    1   3   5   9   10  22

*  冒泡排序  
    執行順序：  
    1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
    2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
    3.针对所有的元素重复以上的步骤，除了最后一个。  
    4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较  
    冒泡排序代码：  
    [http://blog.csdn.net/u012661010/article/details/72891623][http_blog.csdn.net_u012661010_article_details_72891623]
 *  查找（在指定数组中查找某个元素的位置）

public class Demo5 {
        public static void main(String[] args) {
            int[] arr = {
       1,22,5,9,3,10};
            int index = getIndex(arr, 5);
            System.out.println("index = " + index);
        }
        public static int getIndex(int[] arr,int value) {
            for (int i = 0; i < arr.length; i++) {
                if(arr[i] == value) {
                    return i;
                }
            }
            return -1; //返回-1代表数组中不存在此元素，因为数组的角标是从0开始的。
        }
    }
    结果：
    index = 2

*  折半查找  
    具体的执行流程如下：  
    ![这里写图片描述][SouthEast 1]  
    代码实例：  
    注意：  
    
    
     *  必须采用顺序存储结果
     *  关键字必须有序

public class Demo6 { 
        public static void main(String[] args) {
            int[] arr = {
       1,22,5,9,3,10};
            selectSort(arr);
            int  index = binarySearch(arr, 10);
            System.out.println(index);
        }
    
        //选择排序
            public static void selectSort(int[] arr) {
                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[j];
                            arr[j] = arr[i];
                            arr[i] = temp;
                        }
                    }
                }
    
            }
        /** * 折半查找 */
        public static int binarySearch(int[] arr,int key) {
    
            int min = 0;
            int max = arr.length - 1;
            int mid = (min+max)/2;
    
            while(arr[mid] != key) {
                if(key > arr[mid]) {
                    min = mid + 1;
                }else if(key < arr[mid]) {
                    max = mid - 1;
                }
                if(max < min) {
                    return -1;//表示没有找到此元素
                }
                mid = (max + min) / 2;
            }
    
            return mid;
        }
    }

面试题：  
给定一个有序的数组，如果在数组中存储一个元素，并保证这个数组还是有序的，那这个元素的存储的角标如何获取。  
（提示：只需将上面程序中的返回值-1改为min）

## 5.二维数组 ##

格式1：  
int\[\] \[\] arr =new int\[3\] \[2\];  
定义了名称为arr的二维数组  
二维数组中有三个一维数组  
每一个一维数组有2个元素  
一维数组的名称分别为arr\[0\],arr\[1\],arr\[2\]  
给第一个一维数组1角标赋值为78的写法是：arr\[0\]\[1\]= 78;

java打印对角线都为1，其他为0的二维数组
    public class Demo7 { 
        public static void main(String[] args) {
            System.out.println("TEST array!");
            // 调用系统函数获取键盘输入事件
            Scanner sc = new Scanner(System.in);
            // 获取键盘输入的值
            int n = sc.nextInt();
            Demo7.printArray(Demo7.createArray(n));
        }
    
        /** * 根据输入的数创建二维数组（对角线都为1，其他为0） * * @param n * @return */
        public static int[][] createArray(int n) {
            // 创建一个二维数组
            int array[][] = new int[n][n];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if (i == j || i == n - 1 - j) {
                        array[i][j] = 1;
                    } else {
                        array[i][j] = 0;
                    }
                }
            }
            return array;
        }
    
        /** * 打印数组 * * @param array */
        public static void printArray(int[][] array) {
            // 打印二维数组
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    System.out.print(array[i][j] + " ");
                }
                System.out.println();
            }
        }
    
    }

## 6.Arrays类 ##

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

*  具有以下功能：  
    给数组赋值：通过 fill 方法。  
    对数组排序：通过 sort 方法,按升序。  
    比较数组：通过 equals 方法比较数组中元素值是否相等。  
    查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。  
    ![这里写图片描述][SouthEast 2]

[SouthEast]: /images/20220613/8d6c5ef9406144ee88ff9fd919495a9f.png
[http_blog.csdn.net_u012661010_article_details_72891623]: http://blog.csdn.net/u012661010/article/details/72891623
[SouthEast 1]: /images/20220613/931ab5fc78b6496a8131b5f532853cde.png
[SouthEast 2]: /images/20220613/cb09c02c745c4db09900902872a28b9c.png