数组

一、数组介绍

数组可以存放多个同一类型的数据
数(数据)组(一组)——数组就是一组数据，什么样的数据？同一类型的数据
数组也是一种数据类型，是引用类型

二、数组的使用

动态初始化

语法

//方式一
//数据类型 数组名[] = new 数据类型[大小];
//数据类型[] 数组名 = new 数据类型[大小];
int[] arr1 = new int[5];
int arr2[] = new int[5];//创建了一个数组，名字arr2，存放五个int
//形象化解释：酒店三楼有5个房间，arr2就相当于楼层三楼，五个int就相当于那五个房间


//方式二
//1、先声明数组
//数据类型 数组名[];
//数据类型[] 数组名;
int a[];//这时a 是null
int[] b;

//2、创建数组
//数组名 = new 数据类型[大小];
a = new int[5];//分配内存空间，可以存放数据

先确定大小，再赋值

静态初始化

语法

//静态初始化
//数据类型[] 数组名 = {.......}
//数据类型 数组名[] = {.......}
int a[] = {1,1,1,};


//这种用法相当于
int b[] = new int[3];
b[0] = 1;
b[1] = 1;
b[2] = 1;

如果数组值有限，知道具体值，可使用这种初始化方法
直接赋值

特别

String strs[] = new String[]{"a","b"}; //是正确的使用方式

数组的引用

数组名[下标/索引/index]：比如数组的第一个元素 a[0]，数组下标从0开始
a.length表示数组的长度/大小

三、数组使用注意事项和细节

数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
数组创建后，如果没有赋值，有默认值：int/short/byte/long --> 0,float/double ---> 0.0;char --> \u0000,boolean --> false,String --> null
使用数组的步骤：1、声明数组并开辟空间；2、给数组各个元素赋值；3、使用数组
数组的下标是从0开始的
数组的下标必须在指定范围内使用，否则报：下标越界异常，比如 int[] arr = new int[5],则有效下标为0-4
最小下标：0 最大下标：数组长度-1
数组属于引用类型，数组型数据是对象(object)
int a[] = new int[5];//a是数组，是引用类型，a[下标]是一个元素，是基本数据类型int

四、数组赋值机制

基本数据类型赋值，这个值就是具体的数据，而且相互不影响
数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
地址相同，指向的数据空间相同，数据有变化会相互影响

五、数组拷贝

将int[] arr1 = {10,20,30}; 拷贝到arr2数组，要求数据空间是独立的

public class Main {
    public static void main(String[] args) {
        //数组拷贝
        //1 创建一个数组 int[] arr1 = { 10 , 20 , 30 };
        //2 创建一个新数组arr2，大小为arr1.length  int[] arr2 = new int[arr1.length];
        //3 遍历arr1，把每个元素拷贝到arr2对应的元素位置
        int[] arr1 = { 10 , 20 , 30 };
        int[] arr2 = new int[arr1.length];//开辟新空间
        //遍历arr1，把每个元素拷贝到arr2对应的元素位置
        for(int i = 0;i < arr1.length;i++){
            arr2[i] = arr1[i];
        }
        System.out.println("======arr2=======");
        for(int i = 0;i < arr2.length;i++){
            System.out.print(arr2[i]+"\t");
        }
    }
}

六、数组反转

要求：把数组元素反转 arr{11,22,33,44,55,66}-->{66,55,44,33,22,11}

public class Main {
    public static void main(String[] args) {
        //数组反转
        //方法一：找规律
        //1 把arr[0] 和 arr[5] 交换 {66,22,33,44,55,11}
        //2 把arr[1] 和 arr[4] 交换 {66,55,33,44,22,11}
        //3 把arr[2] 和 arr[3] 交换 {66,55,44,33,22,11}
        //一共交换 3次 = arr.length/2
        //每次交换时，对应下标是 arr[i] 和 arr[arr.length-1-i]

        //创建数组
        int[] arr = {11,22,33,44,55,66};
        //优化
        int temp = 0;
        int len = arr.length;
        //交换元素
        for(int i = 0;i < len/2;i++){//i表示下标从0开始
            temp = arr[len-1-i];//利用临时变量来保存数据，便于交换
            arr[arr.length-1-i] = arr[i];
            arr[i] = temp;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        //数组反转
        //方法二：逆序赋值方式
        //1 创建一个新数组长度为arr.length  int[] arr2 = new int[arr.length];
        //2 逆序遍历arr，把每个元素拷贝到arr2的元素中(顺序拷贝)
        //3 增加一个循环变量 j -> 0 - 5

        int[] arr = {11,22,33,44,55,66};
        int[] arr2 = new int[arr.length];
        //逆序遍历arr，把每个元素拷贝到arr2的元素中(顺序拷贝)
        //不用规定j的条件，整个循环执行五次就结束了，j肯定是0-5
        for(int i = arr.length-1,j = 0;i >= 0;i--,j++){
            arr2[j] = arr[i];
        }
        //4 当for循环结束，arr2就是一个逆序的数组
        //5 让arr指向arr2的数据空间，此时arr原来的数据空间没有变量引用会被当做垃圾销毁
        arr = arr2;
        
    }
}

七、数组添加

要求：实现动态的给数组添加元素的效果，实现对数组扩容

原始数组使用静态分配int[] arr = {1,2,3}

增加的元素4，直接放在数组的最后 arr = {1,2,3,4}

用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        //数组添加
        //要求分两部分：添加元素 + 是否继续

        //添加元素部分
        //1、定义初始数组 int[] arr = {1,2,3};  下标0-2
        //2、定义一个新的数组 int[] arrNew = new int[arr.length+1];
        //3、遍历arr数组，依次把arr的元素拷贝到arrNew数组  arrNew[i] = arr[i];
        //4、最后把4赋给arrNew的最后一个元素 arrNew[arrNew.length-1] = 4;
        //5、把arrNew赋给arr   arr = arrNew;   原来的arr数组就被销毁

        //是否继续部分
        //6、定义一个Scanner对象
        //7、要先执行一次，什么时候退出不确定——————采用do-while + break来控制

        int[] arr = {1,2,3};
        Scanner myScanner = new Scanner(System.in);
        do{
            int[] arrNew = new int[arr.length+1];
            //历arr数组，依次把arr的元素拷贝到arrNew数组
            for(int i = 0;i < arr.length;i++){
                arrNew[i] = arr[i];
            }
            //把添加的值赋给arrNew的最后一个元素
            arrNew[arrNew.length-1] = arr.length+1;
            arr = arrNew;
            //数组扩容后的情况
            for(int j =0;j < arr.length;j++){
                System.out.print(arr[j]+" ");
            }
            System.out.println();
            System.out.println("是否继续添加y/n");
            char answer = myScanner.next().charAt(0);
            if(answer == 'n'){
                break;
            }
        }while(true);
        System.out.println("你退出了添加.....");
    }
}

本文章使用limfx的vscode插件快速发布