Java基础—数组

概念

        是内存中一块连续的存储空间，作用为同时存放多个相同数据类型的值。

创建

       规范：数组创建时必须指明长度，作用为方便内存分配空间。

       创建方式：

        1. 先声明，再指明长度（数组创建时必须指明长度（必须为整型），方便内存分配空间）。

        2. 声明同时直接指明长度。

        3. 创建的同时直接存放数据。（数组长度由存放的值的个数决定，不可再次指明长度）

                使用该方式创建数组时，数组的长度由值的个数决定，且不可再次指明长度

//先声明，后指明长度

数据类型 []数组名;//声明
数组名=new 数据类型[长度];//指明长度

int []arr;
arr=new int[3];


//声明的同时直接指明长度

数据类型[] 数组名=new 数据类型[长度];

int[] arr2 = new int[3];


//创建的同时直接存放数据

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

int[] arr3=new int[]{10,20,30,40};
int[] arr4 = {10, 20, 30};//简写

使用

        1. 通过下标操作数组元素

        2. 下标从0开始，至数组长度前一位结束

        3. 通过下标取值赋值

        4. 下标的使用不可超出范围，否则会报出数组下标越界异常                           （java.lang.ArrayIndexOutOfBoundsException;）

        5. 可以通过数组名 . length动态获取数组长度

遍历

        依次获取查看数组的数据

for(int i=0;i<数组名.length;i++){
    //i代表下标
    //通过数组名[i]获取当前正在被遍历的元素值
}

example：

		for (int i = 0; i < arr.length; i++) {
            //获取当前数组元素
            System.out.println(arr[i]);
        }

数组高级

深入数组底层

        1.数组是引用类型

        2. 底层存放：栈中存放引用名（数组名），引用名对应堆中的一块空间，堆空间中存放数组的具体信息（值）

        3. 一用类型之间互相赋值传递的是堆地址。（堆地址中内容改变，指向该地址的所有引用对应的值都改变）

        4. 逢new必开：只要执行到new关键字，堆中一定会开辟空间

        5.  为了保证内存空间的正常分配，数组存在默认值

                默认值：是编译器对空间的第一次赋值

                初始值：手动给予的第一次赋值

                各个数据类型系统默认值：

                        int： 0

                        double ：0.0 

                        Boolean ：false

                        char： 空字符

                        String ：null

数组扩容

        步骤：创建一个长度更大的数组（通常为原数组的2倍），再将原数组的数据赋值到新数组中，最后将引用的地址转向新数组。

for循环方法

public static void main(String[] args) {
        //原数组：整型数组
        int a[] = {10, 20, 30, 40, 50};
        //需求：将数组a扩容2倍

        //1. 创建一个长度为a的2倍的数组
        int[] newA=new int[a.length*2];//{10,20,30,40,50,0,0,0,0,0}
        //2. 将原数组数据复制到新数组中
        //遍历数组a
        for (int i = 0; i < a.length; i++) {
            //将当前元素的值赋值给新数组
            newA[i] = a[i];
        }
        //3. 将引用的地址转向新数组地址
        a = newA;

        //查看原数组数据
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

    }

arraycopy方法

        System.arraycopy（原数组名，原数组复制起始下标，新数组名，新数组存放起始下标，复制长度）

        //原数组：整型数组
        int a[] = {10, 20, 30, 40, 50};
        //需求：将数组a扩容2倍

        //1. 创建一个长度为a的2倍的数组
        int[] newA=new int[a.length*2];//{10,20,30,40,50,0,0,0,0,0}
        //2. 将原数组数据复制到新数组中
        System.arraycopy(a,0,newA,0,a.length);

        //3. 将引用的地址转向新数组地址
        a = newA;

copyOf方法

        新数组地址 java.util.Arrays.copyOf（原数组名，预期数组长度）

        int a[] = {10, 20, 30, 40, 50};
        //需求：将数组a扩容2倍

        a=Arrays.copyOf(a, a.length * 2);

数组排序

冒泡排序

        1. 让相邻的两个位置进行比较，每轮比较之后都会确定一个值（从后往前）

        2. 实现思路：外层循环代表轮数，内层循环代表次数

int a[] = {55, 11, 66, 44};

        for (int i = 1; i < a.length; i++) {//轮数
            for (int j = 0; j < a.length - i; j++) {//次数
                //让下一元素和当前元素进行比较
                //从小到大：小于号  从大到小：大于号
                if (a[j + 1] < a[j]) {
                     //交换值
                    int temp = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = temp;
                }
            }
        }

选择排序

        1.固定一个下标位置，让其他下标位置与其比较，根据比较结果决定是否换位

        2. 每轮比较结束后，固定下标位置的值将被确定

        3.实现思路：外层循环循环代表轮数，内层循环代表次数

int[] a = {99, 55, 77, 1};
        for (int i = 0; i < a.length - 1; i++) {//固定的下标范围
            for (int j = i + 1; j < a.length; j++) {//比较的下标
                //判断比较位置的值是否小于固定位置的值
                //从小到大：小于号  从大到小：大于号
                if (a[j] < a[i]) {
                    //值换位
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }

JDK排序

        java.util.Arrays.sort(数组名)：对数组元素进行快速的升序排列（只能进行从小到大排序）

int[] a = {55, 99, 77, 1};

Arrays.sort(a);

重点掌握

1. 数组的创建语法

2. 下标的使用

3. 数组的遍历

4. 数组的数据类型

5. 引用类型相互赋值的特点

6. 数组扩容的步骤

         步骤+arraycopy和copyOf方法的传参及返回值

7. 排序方式的实现