Java进阶：Array数组

Array

一维数组

1. Java语言中的数组是一种引用数据类型。存储在堆内存中。
2. 数组的父类是Object。
3. 数组是一个数据的集合。
4. 数组一旦创建，在Java中规定，长度不可变。
5. 所有的数组对象都有length属性，用来获取数组中元素的个数。
6. java中的数组要求数组中元素的类型统一。
7. 所有数组都是拿第一个的地址作为整个数组对象的内存地址。
8. 优点：检索效率高。
   
9. 缺点：1.由于为了保证数组中每个元素的内存地址连续，所以在数组上进行增加、删除操作时效率较低（除了数组最后一个元素）。2.数组不能存储大数据量，因为很难在内存空间上找到一块特别大的连续的内存空间。
10. 一维数组语法格式： 数据类型[] 数组名；
11. 一维数组的初始化：
    静态初始化语法格式：
    int[] array = {100, 200, 300};
    动态初始化语法格式：
    int[] array = new int[5];
    Object[] = new Object[6]; //可以存储自身和子类
12. String[] args数组主要是用来接收用户输入的参数的，默认0
13. java中数组的扩容：（效率很低，要尽量减少数组的扩容次数）
    先新建一个大容量的数组，然后将小容量数组中的数据一个一个拷贝到大容量的数组中。
    语法格式：System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

二维数组

1. 二维数组由多个一维数组组成
2. 语法格式：
   静态初始化：
   int[][] array = {{1,2,3,…},{4,5,6,…},…}
   动态初始化：
   int[][] array = new int[2][3];
   Object[][] o = new Object[5][6];
3. array[0][0] 表示第一个一维数组中的第一个元素

代码示例

例子1

public class ArrayTest {
    public static void main(String[] args) {
        //静态初始化方式声明一个int类型的数组
        //int[] array = {1, 100, 10, 20 ,50,80};
        //动态初始化方式声明一个int类型的数组
        int[] array = new int[6];   //数组长度为6
        //赋值前默认0
        array[0] = 1;

        System.out.println("数组中元素的个数"+array.length);
        System.out.println("数组中第一个元素"+array[0]);
        System.out.println("数组中最后一个元素"+array[5]);
        System.out.println("数组中最后一个元素"+array[array.length-1]);

        //遍历数组
        for (int i = 0; i < array.length; i++){
            System.out.println(array[i]);
        }

        //动态初始化方式声明一个Object类型的数组
        Object[] array1 = new Object[6];   //数组长度为6
        //赋值前默认null
        array1[0] = new Object();

        System.out.println("数组中第一个元素"+array1[0]);   //数组中第一个元素java.lang.Object@1540e19d
    }
}

例子2

public class ArrayTest1 {
    public static void main(String[] args) {
        //静态初始化方式声明一个int类型的数组
        int[] a = {1,2,3};
        printArray(a);
        printArray(new int[]{1,2,3});

        //动态初始化方式声明一个int类型的数组
        int[] a1 = new int[3];
        printArray(a1);
        printArray(new int[3]);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++){
            System.out.print(array[i]);
        }
        System.out.println();
    }
}

例子3：String[] args数组

public class ArrayTest2 {
    public static void main(String[] args) {
        //JVM默认传递过来的这个数组对象的长度，默认0
        //通过测试得出：args不是null
        System.out.println("JVM给传递过来的String数组参数，长度为" + args.length);

        //String[] args数组主要是用来接收用户输入的参数的
        //例如：java ArrayTest2 abc def xyz
        //JVM会通过空格的方式进行分离，放入String[] args数组中
        //转换成：{"abc","def","xyz"}
    }
}

例子4：数组拷贝

public class ArrayTest3 {
    public static void main(String[] args) {
        //拷贝源
        int[] src = {1,2,3};
        //拷贝目标
        int[] dest = new int[10];
        //调用JDK System类中的arraycopy方法，来完成数组拷贝
        //System.arraycopy(拷贝源,拷贝源的起始位置,拷贝目标,拷贝目标的起始位置,拷贝长度);
        System.arraycopy(src,1,dest,3,2);//拷贝2，3到dest数组第三个位置
        //遍历目标数组
        for (int i = 0; i < dest.length; i++){
            System.out.println(dest[i]);
        }
    }
}

例子4：二维数组

public class ArrayTest4 {
    public static void main(String[] args) {
        //二维数组的静态初始化
        /*
        int[][] arr = {
                {1,2,34},
                {54,4,34,3},
                {2,34,4,5}
        };
        */
        //二维数组的动态初始化
        int[][] array = new int[2][3];
        //遍历数组
        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();
        }
    }
}