第十三章-多维数组
我们在上一章中学习了的一维数组只能线性存储数据，像复杂一点的表形式结构就表示不出来。而我们本章将要学到的多维数组则可以解决这个问题，多维数组可以简单理解成数组的数组。以二维数组为例，它存储结构可以看成一个表状的存储结构而不是像一维数组那样的线性结构。

二维数组的声明创建与一维数组相差不大。一维数组后面只有一个“int one[ ]”,二维数组则是有两个”int one[ ][ ]“(其它多维数组依此类推，这里以最常见的二维数组为例)。
public class Array{
    public static void main(String[] args){
        int one[][]={
            {1,2,3,4},
            {5,6,7,8},
            {9,0,1,2}
        };//方式一
 
        int two[][];
        two=new int[][]{
            {1,2,3,4},
            {5,6,7,8},
            {9,0,1,2}
        };//方式二
        
        int three[][];
        three = new int[3][4];//方式三
    }
}
二维数组的输出依靠嵌套循环来进行输出。
public class Array{
    public static void main(String[] args){
        int i,j;
        int one[][]={
            {1,2,3,4},
            {5,6,7,8},
            {9,0,1,2}
        };//方式一
 
        for(i=0;i<3;i++)
        {
            for(j=0;j<4;j++)
            {
                System.out.printf("one%d=%d  ",i+1,one[i][j]);
            }
            System.out.printf("\n");
            System.out.printf("\n");
        }
    }
}
对于二维数组我们可以把它看成一张表或者平面直角坐标系。他后面的两个方括号即可代表行与列，X轴与Y轴。一维数组中的下标是从“0“开始的，二维数组则是从”00“开始。

数组部分的知识已经讲解完了，学完之后同学们要勤加练习，熟练掌握。在本章中还将对数组的操作进行讲解。在我们学习一维数组时了解到的遍历便是一种对数组的操作。我们本章中学习的二维数组可以使用循环进行遍历，也可以使用forech语句来进行遍历，此处着重讲解forech语句遍历怎样对二维数组进行遍历，不再讲解循环遍历法，相信有兴趣的同学可以自己实现出来的。forech语句遍历二维数组其方法如下。
public class Traversing{
    public static void main(String[] args){
        int one[][]={
            {1,2,3,4},
            {5,6,7,8},
            {9,0,1,2}
        };
 
        for(int[] i:one){
            for(int j:i){
                System.out.println(j);
            }
        }
    }
}
除了遍历之外还有，操作数组元素、数组排序、数组查询、数组复制等操作。在讲解这些前我们需要来了解一下Arrays类。这个类包含了各种操作数组的方法，我们前面例举的四种数组操作都需要借助Arrays类来实现。使用Arrays类前，需要先导入包。使用improt关键字进行导入包操作，Arrays类是在util包中，我们需要先导入util包才能使用Arrays类，否则会报错。
我们先来讲解填充替换数组元素操作，填充替换数组元素需要使用Arrays类中的fill()静态方法(Arrays所有方法都是静态方法)。till()方法有两种参数类型，下面例程中fill()方法将
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
 
        for(int i:one){
            System.out.printf("%d ",i);
        }//打印初始状态
 
        Arrays.fill(one,6);// 对数组中的元素进行替换
        System.out.println();
 
        for(int i:one){
            System.out.printf("%d ",i);
        }//输出填充完元素的数组
    }
}
对数组中的元素进行替换操作。例程中的这种参数类型对数组内所有元素进行操作，所以数组one在执行完“Arrays.fill(one,6); ”后，其元素便都为6。“Arrays.fill(进行元素替换的数组，替换到数组中的值);”
下面这个例程中是fill()方法的另一种参数类型，它的特点是能够指定替换元素的范围。“Arrays.fill(进行元素替换的数组,起始范围,结束范围,替换到数组中的值);”这里需要注意一下起始范围与结束范围的定义，替换的元素包括了起始范围的值，但却不包括结束范围的值“
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
 
        for(int i:one){
            System.out.printf("%d ",i);
        }//打印初始状态
 
        Arrays.fill(one,1,3,6);
        System.out.println();
 
        for(int i:one){
            System.out.printf("%d ",i);
        }
    }
}
数组排序使用的是sort()方法。sort()方法可对任意数据类型数组进行升序排序(升序即为由小至大排序，降序即为由大至小排序)。
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={2,4,6,5,3,1};
        int two[]={2,4,6,5,3,1};
 
        Arrays.sort(one);//参数类型1
 
        for(int i:one){
            System.out.printf("%d ",i);
        }
        System.out.println();
        
        Arrays.sort(two,1,4);//参数类型2
 
        for(int i:two){
            System.out.printf("%d ",i);
        }
 
    }
}
参数类型1是对整个数组进行升序排序操作，参数类型2则是在指定范围内进行升序排序操作，其起始范围定义与结束范围定义与填充替换操作的起始范围定义与结束范围定义一样都是操作的元素包括了起始范围的值，却不包括结束范围的值。
数组的复制使用copyOf()方法与copyOfRange()方法。
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
 
        int two[]=Arrays.copyOf(one,6);
 
        for(int i:two){
            System.out.printf("%d ",i);
        }
        System.out.println();
 
        int three[]=Arrays.copyOf(one,3);
 
        for(int i:three){
            System.out.printf("%d ",i);
        }
    }
}
copyOf()方法复制数组至指定长度，copyOfRange()方法则是将数组指定长度复制到新数组里。其指定长度若大于数组本身长度int整型以0补不足位。
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
 
        int two[]=Arrays.copyOfRange(one,0,2);
 
        for(int i:two){
            System.out.printf("%d ",i);
        }
 
        System.out.println();
 
        int three[]=Arrays.copyOfRange(one,0,8);
 
        for(int i:three){
            System.out.printf("%d ",i);
        }
    }
}
数组查询是用binarySearch()方法，binarySearch()方法使用二分法(又称折半法，一种效率较高的查找算法)进行查找的，
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
 
        int variable1=Arrays.binarySearch(one,2);
        System.out.println(variable1);
 
        int variable2=Arrays.binarySearch(one,8);
        System.out.println(variable2);
 
    }
}
例程中使用的是排好序且没有相同元素的数组，若是未排好序且有相同元素的数组则应先排序，再查询。否则会查找结果可能会出现偏差。
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={5,6,9,4,4,3,9,6,5,9};
 
        int variable1=Arrays.binarySearch(one,9);
        System.out.println(variable1);
 
        Arrays.sort(one);
 
        for(int i:one) {
            System.out.printf("%d ", i);
        }
        System.out.println();
        
        int variable2=Arrays.binarySearch(one,9);
        System.out.println(variable2);
    }
}
比较两数组是否相同使用equals()方法，若两数组元素相同返回true，若俩数组元素不相同则返回false。
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
        int two[]={1,2,3,4,5,7};
        int three[]={1,2,3,4,5,6};
 
        System.out.println(Arrays.equals(one,two));
        System.out.println(Arrays.equals(one,three));
    }
}
转换为字符串使用toString()方法。转换为字符串后数组变的更为容易观察，可以直接打印，而不用循环遍历一个一个打印数组内容了。
import java.util.Arrays;
public class Operating{
    public static void main(String[] args){
        int one[]={1,2,3,4,5,6};
 
        String two=Arrays.toString(one);
        System.out.println(two);
    }
}