数组概述特点&声明&初始化&遍历&拷贝&多维数组&存储表格元素

一、数组概述和特点

数组是相同类型数据的有序集合。

每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。

特点：

1、长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2、其元素必须是相同类型，不允许出现混合类型。

3、数组类型可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

二、数组的声明

数组的声明方式有两种(以一维数组为例)

type[]   arr_name; //（推荐使用这种方式）
type    arr_name[];

1、声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。

2、声明一个数组的时候并没有数组真正被创建。

3、构造一个数组，必须指定长度。

创建基本类型一维数组

public class Test {
    public static void main(String args[]) {
        int[] s = null; // 声明数组；
        s = new int[10]; // 给数组分配空间；
        for (int i = 0; i < 10; i++) {
            s[i] = 2 * i + 1;//给数组元素赋值；
            System.out.println(s[i]);
        }
    }
}

三、数组的初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

1、静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

2、动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

3、数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，

其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null

四、数组的遍历

我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

public class Test {
    public static void main(String[] args) {
        int[] a = new int[4];
        //遍历初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
        //遍历读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

for-each循环（仅适用于遍历）

增强for循环for-each专门用于读取数组或集合中所有的元素，即对数组进行遍历。

public static void main(String[] args) {
        String[] s = { "aa", "bbb", "ccc", "ddd" };
        for (String temp : s) {
            System.out.println(temp);
        }
    }

注意事项

1、for-each增强for循环在遍历数组过程中不能修改数组中某元素的值。

2、for-each仅适用于遍历，不涉及有关索引(下标)的操作。

五、数组的拷贝

System类里也包含了一个

static void arraycopy(object src，int srcpos，object dest， int destpos，int length)方法，

该方法可以将src数组里的元素值赋给dest数组的元素，

其中srcpos指定从src数组的第几个元素开始赋值，

length参数指定将src数组的多少个元素赋给dest数组的元素。

public class TestArrayCopy {
    public static void main(String[] args) {
        //testBasicCopy();
        //testBasicCopy2();
        String[] str = {"阿里","京东","尚学堂","百度","亚马逊"};
        //removeElment(str,1);
        str = extendRange(str);
    }
    //拷贝
    public static void testBasicCopy() {
        String[] s1 = {"aa", "bb", "cc", "dd", "ee"};
        String[] s2 = new String[10];
        arraycopy(s1, 2, s2, 6, 3);
        //s1拷贝到s2，从s1d的下标2开始拷贝，拷贝到s2的下标6，拷贝三个元素
        for (int i = 0; i < s2.length; i++) {
            out.println(i + "--" + s2[i]);
        }
    }
    //测试从数组中删除某个元素(本质上还是数组的拷贝)
    public static void testBasicCopy2() {
        String[] s1 = {"aa", "bb", "cc", "dd", "ee"};
        System.arraycopy(s1, 3, s1, 3-1, s1.length-3);
        s1[s1.length-1] = null;
        for (int i = 0; i < s1.length; i++) {
            out.println(i + "--" + s1[i]);
        }
    }
    //删除数组中指定索引位置的元素，并将原数组返回
    public static String[] removeElment(String[] s,int index){
        System.arraycopy(s, index, s, index-1, s.length-index);
        //删除第一个
        //System.arraycopy(s, index+1, s, index, s.length-index-1);//删除第二个
        s[s.length-1] = null;
        for (int i = 0; i < s.length; i++) {
            out.println(i + "--" + s[i]);
        }
        return s;
    }
    //数组扩容(本质上是：先定义一个更大的数组，然后将原数组内容原封不动拷贝到新数组中)
    /*public static void extendRange() {
        String[] s1 = {"aa", "bb", "cc"};*/
    public static String[] extendRange(String[] s1) {
        String[] s2 = new String[s1.length+10];
        System.arraycopy(s1, 0, s2, 0, s1.length);
        for (String temp : s2) {
            System.out.println(temp);
        }
        return s2;//String[] 有返回值
    }
}

java.util.Arrays类

Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

打印数组

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = { 1, 2 };
        System.out.println(a); // 打印数组引用的值；
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}

此Arrays.toString()方法是Arrays类的静态方法，不是Object的toString()方法。

数组元素的排序和查找

import java.util.Arrays;
public class Test {
    public static void main(String args[]) {
        int[] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        //排序
        Arrays.sort(a);//使用二分法查找，必须先对数组进行排序
        System.out.println(Arrays.toString(a));
        //查找
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12));
    }
}

六、多维数组

二维数组的声明和静态初始化和动态初始化

public class Test2DimensionArray {
    public static void main(String[] args) {
        //int[] a = new int[3];
        //Car[] cars = new Car[3];
        //多维数组声明
        int[][] a = new int[3][];
        a[0] = new int[2];
        a[1] = new int[3];
        a[2] = new int[4];
        System.out.println(a[1][2]);//默认元素都为0
        //多维数组静态初始化
        int[][] b = {
                {1,2,3},
                {4,5,6},
                {7,8,9}};
        System.out.println(b[2][2]);
        //多维数组动态初始化
        a[0] = new int[]{1,2};
        a[1] = new int[]{3,4,5};
        a[2] = new int[]{6,7,8};
        System.out.println(a[1][2]);
    }
}

数组存储表格数据

public class TestArrayTableDate {
    public static void main(String[] args) {
        Object[] a1 = {1001,"高淇",18,"讲师","2006-2-14"};
        Object[] a2 = {1002,"高小七",19,"助教","2007-10-10"};
        Object[] a3 = {1003,"高小琴",20,"班主任","2008-5-5"};

        Object[][] emps = new Object[3][];
        emps[0] = a1;
        emps[1] = a2;
        emps[2] = a3;
        for(Object[] temp : emps){
            System.out.println(temp);
        }
        /*[Ljava.lang.Object;@1b6d3586
            [Ljava.lang.Object;@4554617c
            [Ljava.lang.Object;@74a14482*/
        for(Object[] temp : emps){
            System.out.println(Arrays.toString(temp));
        }
        /*[1001, 高淇, 18, 讲师, 2006-2-14]
            [1002, 高小七, 19, 助教, 2007-10-10]
            [1003, 高小琴, 20, 班主任, 2008-5-5]*/

        /*System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));*/
    }
}