数组、二维数组

1.概念

一组相同类型的数据组合，是一种引用类型。

2.名称

数组名称不是固定的，与其存放的数据的类型有关。
如：存放int类型的数据，
    数组名称     int[]

    存放字符串数据，
    数组名称     String[]

    存放Scanner类型的数据，
    数组名称     Scanner[]

3.元素的概念

数组中的每个数据，都是这个数组的元素。

4.数组的声明和初始化

1）声明： 元素类型[]   变量名;
      元素类型   变量名[];---不推荐

2）变量的初始化的时机：  2种
    （1）声明时直接初始化
    （2）先声明，在初始化（使用前）

3）数组的变量初始化：  3种
    （1）静态初始化
        如：
            String[] names = {"A","B"};
            int[] = {};

    （2）动态初始化
        --规定数组长度
        如：
            int[] ages = new int[length];

        --不规定长度
        如：
            int[] ages = new int[]{};
            double counts = new double[]{1,2,3};

4)默认元素：
整数类型： 默认是 0
浮点数类型： 默认是 0.0
字符类型： 默认'\u0000'
布尔类型： 默认false
引用数据类型： 默认值null

5.数组的长度

即数组元素的个数
表示方式： 变量名.length;

6.数组的下标（index）

下标从0开始，最后一个元素的下标为：length-1
范围：0~length-1

7.数组元素的访问（查看）：

通过下标进行查看
语法： 变量名[index];

元素的遍历（从头到尾依次查看）
for(int i=0;i<变量名.length-1;i++){
    System.out.println(变量名[i]);
}

8.数组的覆盖(赋值、替换)

语法： 变量名[index] = value;

9.数组间的赋值

是指变量之间的赋值。

通过一个变量对数组的元素进行修改，那么与之相关的变量对应的数组元素也会发生变化。

如：
    int[] a = {1,2,3};
    int[] b = a;
    a[1] = 20;

10.引用类型之Arrays

是数组的工具类。此类提供了很多对数组操作的功能方法
如：
    String info = Arrays.toString(数组名);
    Arrays.toString():此方法是将数组的元素一一拼接成字符串。

格式如下：
    "[元素1,元素2,元素3,...,元素length-1]"

11.数组的复制

数组的特点： 一经创建，长度不可变。

系统复制法：
    System.arraycopy(src,start1,des,start2,length);

    src:源数组，即被复制的数组名
    start1:源数组复制的开始下标
    des:目标数组，即复制到的数组名
    start2:目标数组的复制的开始下标
    length:复制的长度

工具类提供的复制方法：（此方法有扩容和缩容的效果）
    语法：
        元素类型[]  变量名 = Arrays.copyOf(src,newlength);

        src:源数组
        newLength:新数组的长度

    功能解释：
            从src的下标为0的元素开始复制，复制到长度为newLength的新数组中，新数组存放元素的开始位置为0

    如：
        int[] nums = {1,2,3,4,5};
        int[] num1 = Arrays.copyOf(nums,5);
        System.out.println(Arrays.toString(num1));
/* 创建一个int类型的数组num2，长度为10，存储前五个元素为num1的内容*/
        int[] num2 = Arrays.copyOf(num1,10);
        System.out.println(Arrays.toString(num2));
/* 创建一个数组num3，长度为4，存储num1的前四个元素*/
        int[] num3 = Arrays.copyOf(num1,4);
        System.out.println(Arrays.toString(num3));

12.引用类型数组

基本数据类型数组，元素是基本类型的数据。
引用数据类型数组，元素是对象

引用数据类型的数组使用规定长度的方式进行初始化时，
 默认值是null;
 如:
    Cell[]  cs = new Cell[10];

cs里有地址，数组对象的地址。此对象里有10个null。

    第一个元素存储(0,3)的方格
cs[0] = new Cell(0,3);
    第二个元素存储(0,4)的方法
cs[1] = new Cell(0,4);

PS:引用类型的数组对象内，存储的是元素对象的地址信息  

13.二维数组

1）概念：
    数组的元素依然是数组
   如：
    x={
         {1,2,3},
         {1,2,3},
         {4,5,6}
      }
   x数组的元素：都是等长的数组，类似于矩阵。

   y ={
         {1,2},
         {1,2,3},
         {1}
       }
   y数组的元素：不是等长的数组。

2）二维数组的初始化：
    静态初始化
        如：
            int[][] a = {{1},{1,2},{1,2,3,4}};

    动态初始化
    （1）等长式初始化
        如：
            int[][] a = new int[3][2];
            表示a有三个元素，每个元素都是2个长度的数组

    （2）只规定高维数组的长度
        如：
            int[][] a = new int[3][];
            表示a有三个元素，但都是null，不能直接进行赋值
            null在使用时，需要新建数组对象（长度任意）     

/*二维数组的声明和初始化*/

/*静态初始化：*/
int[][] a = {{1,2},{3,4,5},{6,7}};
/*使用for循环进行遍历*/
for(int i=0;i<a.length;i++){
    int[] n = a[i];
    //System.out.println(Arrays.toString(n));
    for(int j=0;j<n.length;j++){
        System.out.print(n[j]+"");
    }
    System.out.println();
}
/* 动态初始化
    二维数组等长式初始化，考虑数组下标越界异常
*/
int[][] b = new int[6][5];
//访问输第一个数组
b[0][0] = 1;
//b[0][5] = 7;
System.out.println(Arrays.toString(b[0]));
/*动态初始化
    只规定了高维数组的长度。
    里面的元素是null，
*/
int[][] c = new int[3][];
//输出c的第一个元素
System.out.println(Arrays.toString(c[0]));
c[0] = new int[2];//将null替换成数组对象
c[0][0] = 1;
c[0][1] = 2;
System.out.println(c[0]);
System.out.println(Arrays.toString(c[0]));
c[1] = new int[3];
c[1][1] = 4;
System.out.println(Arrays.toString(c[1]));

c[2] = new int[2];
c[2][1] = 2;
System.out.println(Arrays.toString(c[2]));