@TOC二维数组初始化及输出
 
//二维数组动态初始化及输出
 
int[][] at=new int[2][];
at[0]=new int[2];
at[1]=new int[3];

at[0][0]=10;
at[0][1]=11;
at[1][0]=20;
at[1][1]=21;
at[1][2]=22;

int num=0;
while(num<at.length){
  for (int i = 0; i < at[num].length; i++) {
    System.out.print(at[num][i]+"   ");
  }
  System.out.println();
  num++;
}
 
//二维数组静态初始化及输出
 
int[][] arr = {{11,12},{21,22,23},{30,31,32,33}};

for (int[] is : arr) {
  for (int i = 0; i < is.length; i++) {
    System.out.print(is[i]+"   ");
  }
  System.out.println();
}

小试牛刀，简单的二维数组初始化
 小生初次进军CSDN，如有错误，望诸位海涵
 
/*第一种方法*/
int a[][]={{1,3，5}，{7,9，11}}；
/*第二种方法*/比较常用
int b[][]=new int [][]{{2,4,6},{8,10,12}};
/*第三种方法*/
int c[][]=new int[2][3];//先给数组分配内存空间空间
c[0]=new int[]{1,2,3};//先给第一行分配一个一维数组
c[1][0]=5;
c[1][1]=2;
c[1][2]=1;
 
一首《清平调一》的横版和竖版输出，利用二维数组输出且代码如下：
 
package libai;
public class meihua {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
     char a[][]=new char[4][];              //数组初始化
     a[0]=new char[]{'云','想','衣','裳','花','想','容'};
     a[1]=new char[]{'春','风','拂','揽','露','华','浓'};
     a[2]=new char[]{'若','非','群','玉','山','头','见'};
     a[3]=new char[]{'会','向','瑶','台','月','下','逢'};
     
     System.out.println("");
     System.out.println("...横板输出...");
     for(int i=0;i<a.length;i++) {
    	 for(int j=0;j<a[i].length;j++) {
    		 System.out.print(a[i][j]);
    	 }
//标点符号：奇行为“，”偶行为“。”
    	 if(i%2 == 0) {
    		 System.out.println(", ");
    	 }else {
    		 System.out.println(". ");
    	 }
     }
//竖版输出
     System.out.println("...竖版输出...");
     for(int j=0;j<7;j++) {
    	 for(int i=0;i<=3;i++) {
    		 System.out.print(a[i][j]);
    	 }
     System.out.println();
         }
     System.out.println(",.,.");
	}
}


 
运行结果，请君过目
 

数组属于引用数据类型，在使用前必须初始化，否则会报NullPointerException（空指针异常：运行时异常）
  一维数组初始化：
 动态初始化：（声明并开辟数组）
  数据类型[ ] 数组名称=new 数据类型[长度]

 int[ ] data=new int [5] :声明并开辟一个长度为5的数组
 
数组通过下标索引来获取元素，下标默认从0开始。数组下标超出数组长度，数组越界异常（运行时异常）
 
数组中每个元素都有默认值，默认值是该数据类型默认值
 
数组长度：数组名称.length
 
数组遍历推荐使用JDK1.5 提供for-each循环（仅限于数组内容读取），要修改数组内容，还是使用常规for循环
 
    for(int x : data)
 
{
 System.out.println(x+" ");
 }
 引用传递：多个栈内存指向同一块堆内存
 
int[ ] tmp=data; //引用传递 注意是地址的传递
 tmp[3]=10; ----> x[3]=10;
 
数组静态初始化
 简化格式：
 数据类型[ ] 数组名称 ={值，值…}
 完整格式: （推荐使用）
 数据类型[ ] 数组名称 =new 数据类型[ ]{值，值…}
 int[ ] data =new int[ ] {1,2,3} ;
 
长度 ：数组名称.length ,静态初始化长度固定，根据值的个数确定长度，并且长度不可修改
 
匿名数组：没有任何栈内存指向，在使用一次后会变成垃圾，只会使用一次
 
二维数组
动态初始化:数据类型[ ][ ] 数据名称 =new 数据类型[ 行个数] [列个数]

 int[ ] [ ]data =new int [3][4];开辟行数为3，列数为4的整型数组
 
静态初始化：
 数据类型[ ][ ] 数组名称 =new 数据类型[ ][ ]{ {第一行的值},{第二行的值}…}
 
int[ ][ ] data={{1,2，3}，{4,5,6}，{7}}；
 
x<data.length
 
y<data[x].length
 
对象数组初始化：
 
首先看对象数组动态初始化：
 
对象数组动态初始化
public class ArrayDemo
{
    public static void main(String[] args)
    {
        String[] str=new String[3];  //数组动态初始化，每个元素都是其对应数据类型的默认值
        for(String num :str)
        {
            System.out.print(num+"、"); //null、null、null、
        }
        str[0]=new String("pick");
        str[1]=new String("happy");
        str[2]=new String("day");
       for(String num :str)
       {
           System.out.print(num+"、"); //pick、happy、day、
       }
    }
}
 
对象数组静态初始化：
 
public class ArrayDemo
{
    public static void main(String[] args)
    {
        String[] str=new String[]{"pick","happy","day"};  //数组静态初始化，pick、happy、day、
       for(String num :str)
       {
           System.out.print(num+"、"); //pick、happy、day、
       }
    }
}

1、int二维数组初始化方式
 
int A[2][3] = {1, 2, 3, 4, 5, 6};
对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=5; A[1][2]=6;

int A[2][3] = {1, 2, 3, 4};
其中剩余的未赋值元素编译器自动初始化为0。
数组元素值对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=0; A[1][2]=0;

int A[2][3] = {{1, 2, 3}, {4}};
其中剩余的未赋值元素编译器自动初始化为0。
数组元素值对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=0; A[1][2]=0;

int A[][3] = {{1, 2, 3}, {4}};
省略行数，切记列数无法省略。其中剩余的未赋值元素编译器自动初始化为0。
数组元素值对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=0; A[1][2]=0;
 
2、char二维数组初始化方式
 
char A[2][3] = {'a', 'b', 'c', 'd'};
其中未初始化的部分，编译器自动初始为'0'（NULL）。
printf("%s\n", A);
输出"abcd"

char A[2][3] =  {{'a'}, {'d', 'e', 'f'}};
其中未初始化的部分，编译器自动初始为'0'（NULL）。
printf("%s\n", A);
输出"a"，输出第一行时遇到结束符导致停止输出。

char A[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
printf("%s\n", A);
输出"abcdef"
    
char A[][3] = {{'a', 'b'}, {'d'}};
省略行数，切记列数无法省略。
printf("%s\n", A);
输出"ab"
 
3、二维数组作为形参
 
想要在函数中传递一个一维数组作为参数，必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。
 
方式1，形式参数是一个指针
void myFunction1(int *param)

方式2，形式参数是一个已定义大小的数组
void myFunction2(int param[10])

方式3，形式参数是一个未定义大小的数组
void myFunction3(int param[])

int param[3] = {0};
myFunction1(param);
myFunction2(param);
myFunction3(param);
int *param2;
myFunction1(param2);
myFunction2(param2);
myFunction3(param2);
 
就函数而言，一维数组作为形参时的长度是无关紧要的，因为 C 不会对形式参数执行边界检查。
 
同样的方式也可以传递一个多维数组作为形式参数？
 
方式1，形式参数是一个指针
void myFunction1(int **param)

方式2，形式参数是一个已定义大小的数组
void myFunction2(int param[2][10])
void myFunction2(int param[2][3])

方式3，形式参数是一个未定义一维宽度的数组
void myFunction3(int param[][3])

方式4
void myFunction4(int (*a)[3])

方式5
void myFunction5(int *a[3])

int param[2][3] = {0};
myFunction1(param);
错误，[Error] cannot convert 'int (*)[3]' to 'int**' for argument '1' to 'void myFunction(int**)'
即int param[2][3]中param其实是"int (*)[3]"类型，不是"int**"类型，这两者不能混用
myFunction2(param);
二维宽度为10的错误，[Error] cannot convert 'int (*)[3]' to 'int (*)[10]' for argument '1' to 'void myFunction2(int (*)[10])'，可以理解为"int (*)[3]"和"int (*)[10]"不是一种类型
为3的正确，二维数组作为函数形参会进行边界检查，所以第二个维度必须一致
myFunction3(param);
myFunction4(param);
myFunction5(param);
错误，注意如果是int *a[3]，因为"[]"的优先级比"*"高，所以会导致该形参被编译器识别为"int**"

int **param2 = (int **)malloc(sizeof(int *) * 2);
myFunction1(param);
myFunction2(param);
myFunction3(param);
myFunction4(param);
myFunction5(param);
只有myFunction1和myFunction5正确，其余的形参都不是"int**"类型
注意myFunction5中的"a[3]"类似一维数组作形参的效果，不管数组大小都被当作"int *"
 
4、综合例子
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 二维数组作为函数的形式参数会进行边界检查，所以第二个维度必须为5 
void example(char acHello[][5])
{
	printf("%d\n", sizeof(char (*)[5])); // 输出8
	printf("%d\n", sizeof(acHello)); // 输出8，为sizeof(char (*)[5])，指针为8 
	printf("%d\n", strlen(acHello[0])); // 输出9，因为acHello[0]并没有'\0'结束符，所以是acHello的总长度 
	acHello[0][0] = 'c';
	return;
}

int main(void)
{
	char str[] = "\\\\";
	printf("%d\n", sizeof(str)); // 输出3，\\其实是转义，所以2个'\'加字符串自带的1个'\0'是3 
	printf("%d\n", strlen(str)); // 输出2，即2个'\' 
	
	char *str2 = "\\\\";
	printf("%d\n", sizeof(str2)); // 输出8，str是char*类型的指针，指针在64位下都是8 
	printf("%d\n\n", strlen(str2)); // 输出2，即2个'\' 

	char str3[2][3] = {"qw", "er"};
	printf("%c ", *(*(str3 + 0) + 0));
	printf("%c ", *(*(str3 + 0) + 1));
	printf("%c ", *(*(str3 + 1) + 0));
	printf("%c\n", *(*(str3 + 1) + 1));

	printf("%c ", *(str3[0] + 0));
	printf("%c ", *(str3[0] + 1));
	printf("%c ", *(str3[1] + 0));
	printf("%c\n", *(str3[1] + 1));

	printf("%c ", str3[0][0]);
	printf("%c ", str3[0][1]);
	printf("%c ", str3[1][0]);
	printf("%c\n\n", str3[1][1]);
	// *(str3 + 0)等效于str3[0]，*(*(str3 + 0) + 0)等效于str3[0][0] 

	char *szStr = "abcde";
	printf("%c\n", szStr[0]); // 输出a 
	printf("%llu\n", szStr); // 输出4210713，该值为"abcde"这个常串中字符a所在的地址
	szStr += 2;
	printf("%c\n", szStr[0]); // 输出c 
	printf("%llu\n\n", szStr); // 输出4210715，该值为"abcde"这个常串中字符c所在的地址

	char dqq[][10] = {{'h', 'e', 'l', 'l', 'o'}, {'q', 'w', 'e'}};
	printf("%s\n", dqq); // 输出hello，因为第一维多的部分被自动初始化为'\0'，所以输出的时候截断了 
	printf("%s\n", dqq[1]); // 将第二维输出，所以是输出qwe
	printf("%c\n\n", dqq[1][0]); // 输出q

	char acHello[][5] = {{'h', 'e', 'l', 'l', 'o'}, {'h', 'e', 'l', 'l'}};
	example(acHello);
	printf("%s\n\n", acHello); // 输出cellohell，由于是传的指针，所以第一个字符被修改为c

	return 0;
}