多维数组可以看成以数组为元素的数组，可以是二维、三维、甚至多维数组，但是实际在运用中，运用的很少，一般使用容器。
eg1.声明二维数组
public class Test{
public static void main(String[] args){
//在Java中多维数组的声明和初始化应从低维到高维的顺序进行
int[][] a = new int[3][];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3];
//int a1[][] = new int[][4]; //错误/非法
}
}
eg2.二维数组的静态初始化
public class Test{
public static void main(String[] args){
int[][] a = {{1,2,3},{3,4},{3,5,6,7}};
System.out.println(a[2][3]);
}
} 
eg3.二维数组的动态初始化
import java.util.Arrays;
public class Test{
public static void main(String[] args){
int[][] a = new int[3][];
//a[0] = {1,2,3}; //错误，没有声明类型就初始化
a[0] = new int[] {1,2};
a[1] = new int[] {2,2};
a[2] = new int[] {2,2,3,4};
System.out,println(a[2][3]);
System.out,println(Arrays.toString(a[0]));
System.out,println(Arrays.toString(a[1]));
System.out,println(Arrays.toString(a[2]));
}
}
执行结果：
多维数组_Object数组存储表格数据
表格是计算机中最普遍的模型，能看到的所有数据本质上都是"表格"；
表格中的数据，每行可以使用一个一维数组存储：
Object[ ] a1 = {1001，高小六，30，英语老师，2-14}；
Object[ ] a2 = {1002，高小七，31，数学老师，10-10}；
Object[ ] a3 = {1003，高小八，32，语文老师，5-5}；
Consideration:这里的基本数据类型1001，本质不是Object对象。JAVA编译器会自动把基本数据类型"自动装箱"成包装类对象。 在这里，我们需要再定义一个二维数组，将上面3个数组放入即可：
Object[ ] [ ] emps = new Object[3] [ ]；
emps[0] = a1；
emps[1] = a2；
emps[2] = a3；
eg1.使用二维数组保存表格数据
import java.util.Arrays;
public class Test{
public static void main(String[] args){
Object[] a1 = {1001,"高小六",30，"英语老师","2-14"};
Object[] a2 = {1002,"高小七",31，"数学老师","10-10"};
Object[] a3 = {1003,"高小八",32，"语文老师","5-5"};
Object[] [] emps = new Object[3][];
emps[0] = a1;
emps[1] = a2;
emps[2] = a3;
System.out.println(Arrays.toString(emps[0]));
System.out.println(Arrays.toString(emps[1]));
System.out.println(Arrays.toString(emps[2]));
}
}
eg2.使用javabean和一维数组保存表格信息
import java.util.Arrays;
public class Test{
public static void main(String[] args){
Emp[] emps = {
new Emp(1001,"高小六",30,"英语老师","2-14"),
new Emp(1001,"高小七",31,"数学老师","10-10"),
new Emp(1001,"高小八",32,"语文老师","5-5")}；
for(Emp e:emps){
System.out.println(e);
}
}
}
class Emp{
private int id;
private String name;
private int age;
private String job;
private String hiredate;
public Emp(int id,String name,int age,String job,String hiredate){
this.id = id;
this.name = name;
this.age = age;
this.job = job;
this.hiredate = hiredate;
}
@Override
public String toString(){
return "[" + id +"," + name + "," + age + "," + job + "," + hiredate +"]";
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
public String getHiredate() {
return hiredate;
}
public void setHiredate(String hiredate) {
this.hiredate = hiredate;
}
}Comparable接口_对象的排序
多个对象做比较，就要有'"比较规则"，然后实现排序，实际上，java中排序算法的底层也依赖Comparable接口。
Comparable接口中只有一个方法：
public int compare To(Object obj) obj 为要比较的对象
在方法中，将当前对象和obj这个对象进行比较，如果大于返回1，等于返回0，小于返回-1.（这里的1也可以是正整数，-1也可以是负整数）。compare To方法的代码也比较固定，如下：
public int compare To(Object o){
Man man = (Man) o;
if(this.age < man.age){
return -1;
}
if(this.age > man.age){
return 1;
}
return 0;
}【测试Comparable接口】使用Arrays类对数组元素进行排序
import java.util.Arrays;
public class Test{
public static void main(String[] args){
Man[] msMans = {new Man(3,"a"),new Man(60,"b"),new Man(2,"c")};
Arrays.sort(msMans);
System.out.println(Arrays.toString(msMans));
}
}
class Man implements Comparable{
int age;
int id;
String name;
public Man(int age,String name){
super();
this.age = age;
this.name = name;
}
public String toString(){
return this.name;
}
public int compare To(Object o){
Man man = (Man) o;
if(this.age < man.age){
return -1;
}
if(this.age > man.age){
return 1;
}
return 0;
}
}
冒泡排序算法
冒泡排序算法是较为常用的排序算法，推荐个网站https://visualgo.net/ (网站里面可以根据程序执行看到动画效果）
冒泡排序的基础算法
冒泡排序算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，这样越大的元素会经由交换慢慢"浮"到数列的顶端。
冒泡排序算法的运作如下：
①比较相邻的元素，如果第一个比第二个大，就交换他们两个。
②对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，在这里，最后的元素应该会是最大的数。
③针对所有的元素重复以上的步骤，除了最后一个。
④持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
eg1.冒泡排序的基础算法
import java.util.Arrays;
public class TestBubbleSort{
public static void main(String[] args){
int[] values = {3,1,6,8,9,0,7,4,5,2};
bubbleSort(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort(int[] values){
int temp;
for(int i = 0; i < values.length;i++){
for(int j = 0; j < values.length -1 -i;j++){
if(values[j]> values[j+1]){
temp = values[j];
values[j] = values[j+1];
values[j+1] = temp;
}
}
}
}
}冒泡排序的优化算法
其实上面的冒泡排序算法，走到第七趟的时候，排序已经完成，可以把上面的冒泡算法优化一下，基于冒泡排序的以下特点：
①整个数列分成两个部分：前面是无序数列，后面是有序数列。
②判断每一趟是否发生了数组元素的交换，如果没有发生，则说明此时数组已经有序，无需再进行后续趟数的比较了，此时就可以中止比较。
eg2.冒泡排序的优化算法
import java.util.Arrays;
public class TestBubbleSort2{
public static void main(String[] args){
int[] values = {3,1,6,8,9,0,7,4,5,2};
bubbleSort2(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort2(int[] values){
int temp;
for(int i = 0; i < values.length;i++){
//定义一个布尔类型的变量，标记数组是否已达到有序的状态
boolean flag = true;
/*内存循环：每一趟循环都从数列的前两个元素开始进行比较，比较到无序数组的最后 */
for(int j = 0; j < values.length -1 -i;j++){
//如果前一个元素大于后一个元素，则交换两元素的值;
if(values[j] > values[j + 1]){
temp = values[j];
values[j] = values[j + 1];
values[j + 1] = temp;
//本趟发生了交换，表明该数组再本趟处于无序状态，需要继续比较;
flag = false;
}
}
//根据标记量的值判断数组是否有序，如果有序，则退出;无序，则继续循环。
if(flag){
break;
}
}
}
}执行结果：
二分法查找
二分法检索（binary search）又称折半检索
数组[7，8，9，10，12，20，30，40，50，80，100]中查询10是否存在？
二分检索的基本思想是设数组中的元素从小到大有序地存放在数组（array）中，首先将给定值key与数组中间位置上元素的关键码（key）比较，如果相等，则检索成功；否则，若key小，则在数组前半部分中继续进行二分法检索；若key大，则在数组后半部分中继续进行二分法检索。这样，经过一次比较就缩小一半的检索区间，如此进行先去，直到检索成功或检索失败。
二分法检索是一种效率较高的检索方法。
eg.二分法查找法的基本算法
import java.util.Arrays;
public class TestBinarySearch{
public static void main(String[] args){
int[] arr = {30,20,50,10,80,9,7,12,100,40,8};
int searchWord = 20; //所要查找的数
Arrays.sort(arr); //二分法查找之前，一定要对数组元素排序
System.out.println(Arrays.toString(arr));
System.out.println(searchWord + "元素的索引：" + binarySearch(arr,searchWord));
}
public static int binarySearch(int[] array,int value){
int low = 0;
int hight = array.length -1;
while(low <= high){
int middle = (low + high)/2;
if(value == array[middle]){
return middle; //返回查询到的索引位置
}
if(value > array[middle]{
low = middle + 1;
}
if(value < array[middle]){
high = middle -1;
}
}
return -1; //上面循环完毕，说明未找到，返回-1
}
}执行结果如下：
