public class Test {
public static void main(String[] args) {
int[] data1=new int[]{
1,2,3};
int[] data2=new int[]{
4,5,6,5};
int x=30;
int y=40;
int[] data3 ={
x,y};
int[][] data4 = new int[][]{
data1,data2,data3};
for(int i=0;i< data4.length;i++){
System.out.println(data4[i]);
for(int j=0;j<data4[i].length;j++){
System.out.print(data4[i][j]+" ");
}
System.out.println();
}
System.out.println("==============================");
for (int[] aa:data4
) {
for (int xx:aa
) {
System.out.print(xx+" ");
}
System.out.println();
}
}
}
package com.wkcto.chapter03.demo01;
import java.util.Arrays;
/**
* 二维数组
* 数组的每个元素是一个一维数组, 即一维数组的数组
*/
public class Test09 {
public static void main(String[] args) {
int [] data1 = {
1,2,3,4,5};
int [] data2 = {
6,7,8};
int x = 10;
int y = 20;
int [] data3 = {
x, y};
/*
* data1/data2/data3是三个数组名, 其实就是一个变量名, 它的数据类型是 int[] 类型
* []表示data1/data2/data3是数组, []前面的int表示数组元素的类型
* 数据类型[] 数组名 = new 类型[长度]
*/
//定义一个数组, 数组中存储data1, data2, data3这三个变量
int[] [] mydata = {
data1, data2, data3};
//mydata是一个数组名, mydata前面的一个[]表示数组, []前面的int[]表示mydata数组中的元素类型
System.out.println( mydata.length ); //3
//遍历mydata数组中存储的整数
for( int i = 0 ; i<mydata.length; i++){
//mydata[0]是 data1, mydata[i]是一个一维数组名
// System.out.println( mydata[i] );
for( int j = 0 ; j < mydata[i].length ; j++){
System.out.print( mydata[i][j] + "\t" );
}
System.out.println();
}
//foreach遍历
for (int[] is : mydata) {
for (int xx : is) {
System.out.print( xx + "\t");
}
System.out.println();
}
//Arrays.deepToString()可以把多维数组中的元素转换为字符串
System.out.println( Arrays.deepToString(mydata));
}
}
import java.util.Arrays;
/**
* 二维数组的动态初始化及静态初始化
*/
public class Test {
public static void main(String[] args) {
//1)二维数组的动态初始化
//定义一个长度为5的二维数组
int[][] mydata = new int[5][];
//2)给二维数组的元素赋值, 二维数组的每个元素是一个一维数组
//二维数组元素中存储的内容是一维数组的引用
mydata[0] = new int[5];
mydata[1] = new int[]{
1,3,5};
int [] data = {
2,5,8};
mydata[2] = data;
//mydata[3]和mydata[4]默认初始化为null
//3)遍历二维数组
for(int i = 0 ; i<mydata.length; i++){
//判断mydata[i]这个一维数组是否为null
for( int j = 0 ; mydata[i] != null && j < mydata[i].length; j++){
System.out.print( mydata[i][j] + "\t");
}
System.out.println();
}
//4)在定义二维数组同时,可以指定一维数组的长度,系统会给一维 数组默认初始化
int[][] mydata2 = new int[5][4]; //二维数组的长度是5, 它的元素是一个长度为4的一维数组
//遍历
for (int[] is : mydata2) {
for (int xx : is) {
System.out.print( xx + "\t");
}
System.out.println();
}
//5)mydata2二维数组的每个元素存储的是一维数组的引用
mydata2[0] = data;
mydata2[1] = new int[]{
4,5,6,7,8,9};
System.out.println( Arrays.deepToString(mydata2));
//6)二维数组的静态初始化
int[][]mydata3 = new int[][]{
data , new int[5] , new int[]{
1,2,3,4} };
System.out.println( Arrays.deepToString(mydata3));
//可以简化为
int[][] mydata4 = {
data, new int[5], new int[]{
1,2,3,4}};
//还可以写为
int[][] mydata5 = {
{
1,2,3,4} , {
5,6,7} , {
8,9}};
System.out.println( Arrays.deepToString(mydata5));
}
}
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[][] myData=new int[5][];
myData[0]=new int[5];
myData[1]=new int[]{
1,2,3,4,5,6};
int[] data = new int[]{
8,9,10};
myData[2]=data;
for(int i=0;i< myData.length;i++){
for(int j=0;myData[i]!=null&&j<myData[i].length;j++){
System.out.print(myData[i][j]+" ");
}
System.out.println();
}
int[][] myData1= new int[5][4];
for (int[] aa:myData1
) {
for (int x:aa
) {
System.out.print(x+" ");
}
System.out.println();
}
myData1[0]=data;
myData1[1]=new int[]{
1,2,3,4,5,6,7,8,9,10};
System.out.println(Arrays.deepToString(myData1));
int[][] mydata3 =new int[][]{
data,new int[5],new int[]{
4,5,6}};
System.out.println(Arrays.deepToString(mydata3));
int[][] mydata4={
data,new int[5],new int[]{
4,5,6}};
System.out.println(Arrays.deepToString(mydata4));
int[][] mydata5={
{
1,2},{
3,4},{
5,6,7,8}};
System.out.println(Arrays.deepToString(mydata5));
}
}
总结
- 二维数组的每个元素存储的数据类型为一维数组，既一维数组的引用
int [] [] data =new int [5] [];
[] data 表明data是一个数组，int [] 表明data数组存储的数据类型为一维数组既一维数组的引用，一个数组存储一个一维数组我们称这个数组为二维数组，一个数组存储一个二维数组我们称这个数组为三维数组，
最重要的一点就是要明白，二维数组存储的是一维数组的引用；就像对象的引用一样，我们有了对象的引用我们就可以对这个对象做任何的操作，所以说我们有了这个一维数组的引用我们就可以对这个一维数组做任何我们想要做的操作。