目录
3.1条件判断
java语言和C 语言类似，主要包括三种基本的控制流结构：
1. 程序顺序执行
2. 程序的判断结构
3. 程序的循环结构
如果把前面所学习的关键字理解成java语言的词汇量的话，那么结构化程序设计就是java语言所谓的”语法”了，这种跟计算机沟通的语言很简单。
前面章节中我们提过，java是以分号(;)作为一个语句的结束的，与换行符没有关系，任何一句表达式后面都必须带有一个分号(;)，这样才算正常结束，否则会报语法错误，例如：
int a=100; System.out.println(a);
以上都成为单条语句，而把多个语句放到一个形如 “{...代码...}”这样代码块中，成为语句块，就是以左大括号“｛”开始，以右大括号结束“｝”的代码我们成为语句块，左右大括号必须成对出现，语句块可以互相嵌套。语句块可以作为一个整体，类似把多个语句块组合成为一个语句块。我们在代码中可以任意使用包含多个语句成为一段语句块,有时也称为程序块。但是在一些情况下，大括号是不可缺少的，比如定义一个类的时候，或者定义一个普通方法时，后面就必须要使用大括号，包住一段语句块。例如以下的：
public class Abc {//这个是必须的
public static void main(String[] args) {//这个是必须的
float a = 346.756565f;
//这个大括号可以删除
{
int b = (int) a + 10; // 将 a 转换为整型
System.out.println(b);
}
}
}
下面我们讲到的条件判断和循环判断的语法是会大量使用到程序块。
判断逻辑是我们生活中最常见的逻辑判断，计算机来执行跟人类思维也是极为类似的：如果[条件成立]就怎样做，否则就那样做。可以这么说，计算机最擅长的就是判断true/false了。
一、if-else 语句
if语句是最常见的判断语句，通过对条件(conditional)的判断觉得程序的走向。其基本格式如下：
if(条件表达式)
语句1
else
语句2
在执行该判断语句前，都是先执行了条件表达式的语句，条件表达式的返回结果必须是布尔值(boolean)，根据条件表达式的返回，如果是true，那么就执行语句1的内容，如果是false就执行else后面的语句2。如下面这个例子：
int i=1; if(i>10) System.out.println(i+"大于10"); else System.out.println(i+"不大于10");
先定义了整型i并赋值1，然后在执行if里面的条件判断式i是否大于10，返回的结果是false，所以执行的是else后面的语句。
在上面的格式中， else是可选部分，所以最简单的条件判断式如下：
if(条件表达式)
语句1
如下面这个例子：
int i=1;
if(i>10)
System.out.println(i+"大于10");
由于条件判断是false，所以这个程序不会输出任何内容。也正是因为else是可选部分，在嵌套使用的时候就会出现理解上的问题，有时候我们面对下面这个例子的时候就会感觉不清晰了。
int i = 1;
if (i > 10)
if (i < 5)
System.out.println(i + "小于5");
else
System.out.println(i + "不大于10");
else是对应那一个if呢？java是与最近一个if配对的。程序员在写代码时，适当的缩进代码也可以提高代码的可读性，当然我们有更好的解决办法。
if和else后面可以跟着语句，当然也可以跟着语句块，其格式如下：
if(条件表达式){
语句块1
}else{
语句块2
}
建议大家在写if语句时，就算后面只有一个语句，也可以使用大括号包住，形成语句块，这样可以提高程序的可读性，如上面的例子，可以修改成为这样：
if (i > 10) {
if (i < 5) {
System.out.println(i + "小于5");
} else {
System.out.println(i + "不大于10");
}
}
二、else-if 语句
有时候条件判断不止两个，可能就需要使用else-if语句了，其语法格式如下：
if(条件表达式)
语句1
else if(条件表达式)
语句2
else if(条件表达式)
语句3
else if(条件表达式)
语句4
...
else
语句
这样的语句在我们以后的编程中会经常用到，判断的过程是从上往下的判断条件表达式，如果第一个返回的是false就会判断第二个，依次类推，但是如果其中一个返回了true，那么就会执行后面的语句，然后整个else-if语句就会退出，后面如果还有else-if语句也不会在去判断执行的了。我们常常也会在最后面添加一个else语句，当然这也是可选的，这样的效果就是如果上面的所有的if判断都是false，那么就会执行else后面的语句。像上面的if-else一样，后面也是可以跟着语句块的，为了增强程序的可读性，我们后面也常常会使用语句块。格式如下：
if(条件1){
条件1==true时执行的逻辑
}else if(条件2){
条件2==true时执行的逻辑
}else if(条件n){
条件n==true时执行的逻辑
}else{
以上条件均不满足而执行的默认的逻辑
}
下面我们具几个实现，比如我们要判断用户年龄小于16岁时不允许登陆游戏网站，那么我们可以使用以下代码：
int uage = 17;
if (uage < 18) {
System.out.println("Sorry,请关注学业!");
} else {
System.out.println("欢迎登陆！");
}
又如下面这个例子，根据成绩的分数情况分别输出不同的等级：
int result=85;//成绩 if(result>90){ System.out.println("优秀"); }else if(result>80){ System.out.println("良好"); }else if(result>60){ System.out.println("合格"); }else{ System.out.println("不合格"); }
if判断也可以嵌套使用，也就是在语句块里也可以包含一个if判断表达式，如下面这个例子。其中Scanner是获得用户输入对象，请看下面这个例子：
import java.util.Scanner;
public class Tt {
public static void main(String[] args) {
int num0;//第一个数
int num1;//第二个数
int type;//计算类型
System.out.print("*"请输入num0: "*");
Scanner scr = new Scanner(System.in);
num0 = scr.nextInt();//程序会在此等待用户的输入
System.out.print("*"请输入num1: "*");
scr = new Scanner(System.in);
num1 = scr.nextInt();
System.out.print("*"请输入计算类型(0表示加 ; 1表示减 ; 2表示乘 ; 3表示除): "*");
scr = new Scanner(System.in);
type = scr.nextInt();
if (type == 0) {
System.out.println(num0 + "*"+"*" + num1 + "*" ="*" + (num0 + num1));
} else if (type == 1) {
System.out.println(num0 + "*"-"*" + num1 + "*" ="*" + (num0 - num1));
} else if (type == 2) {
System.out.println(num0 + "*"*"*" + num1 + "*" ="*" + (num0 * num1));
} else if (type == 3) {
// 除法，使用嵌套的if语句判定除数不能为0
if (num1 == 0) {
System.out.println("*"除数不能为0"*");
} else {
System.out.println(num0+"*"/"*"num1+ "*" ="*" + (num0 / num1));
}
} else {
// 非法输入
System.out.println("*"您的输入有误!计算类型只能是[0,1,2,3]"*");
}
}
}
在这个程序中用了Scnner获得用户的输入，程序运行到scr.nextInt()的时候会停下来，等待用户的输入，用户输入后按回车程序才会继续往下运行，在程序中我们对除法的判断又嵌套了一个除数不能为0的判断。
三、switch选择语句
switch语句是另一种判断语句的写法，这种语句在选择时是对case子句的值进行相等测试，其功能性其实和if判断语句一样，仅仅只是书写的方式不同，两者之间可以互通，语法上面没有if语句简介。其具体的语法格式如下：
switch(被判断的变量)
{
case 条件1:
执行条件1的逻辑
break;
case 条件2:
执行条件1的逻辑
break;
case n:
执行条件n的逻辑
break;
default:
以上条件均不满足而执行的默认的逻辑
}
switch后面的只是被判断的变量，当与case后面的条件相等是，那么case后面的语句就会执行，最后面的default是可选项，可根据你的业务逻辑需要决定是否添加，功能类似else语句，就是上面所有的case条件都不满足时就会执行default后面的语句。
值得注意的是，在JDK 7以前参加被判断的变量的类型只可以是int, byte, char, short等数据类型，但是在JDK 7以后，被判断的变量的类型被增强支持对字符串String的判断。如果你还是使用JDK 6就要特别注意这一点了。
一般来说，switch与case成功匹配，还会继续顺序执行以后所有的程序代码，因此一般都要在判断成功后面添加break语句跳出判断语句块。有关break关键字的详细说明我们会在后面的章节中说明。
看看这个例子：已知变量int month=1，使用switch判断语句，如果month等于1就输出"一月"，等于2就输出"二月"，如此类推。实现代码如下：
int month=4;
switch(month){
case 1:
System.out.println("一月");
break;
case 2:
System.out.println("二月");
break;
case 3:
System.out.println("三月");
break;
case 4:
System.out.println("四月");
break;
//...中间的5~12用户自己补充。
default:
System.out.println("month只能是1~12");
}
3.2循环结构
计算机除了擅长判断外，更多的时候会执行一些循环语句，计算机对这些重复的循环语句的执行非常擅长，java提供了三种基本的循环语句，下面一一详细介绍：
一、while循环语句
while循环语句，它的条件判断表达式只有一个，通过判断条件为true时执行循环体代码块，为false时退出循环。其语法格式如下：
while (判断条件)
{
// 语句
}
循环开始前，程序会先执行判断条件里面的代码，只要返回true就会进入后面的语句块，和if判断一样，如果后面只有一个语句那么左右大括号可以省略，但是为了提高程序的可读性，建立还是写上大括号。
下面我们具几个简单的示例说明while的使用，比如我们要输出十句hello world语句。当然我们不用写10局输出语句，可以参考下面的代码：
int i=0;//初始化 i为0 while(i<10){//进入循环前先判断条件是否为true System.out.println("hello world!"); i++;//每一次循环结束前i自增1 } System.out.println("while循环结束了。i="+i);
使用循环语句我们可以轻松的实现输出10句hello world的程序，注意上面的代码，在循环开始前我们就定义了一个变量i用户控制循环的次数，初始化为0，每一次进入while循环体之前，都会先判断i是否小于10,如果小于10才会进入循环体，在循环体里，我们让i自增1，也就是说每输出已经hello world后，i都会自增1，然后再次回到while循环的判断条件中，再次判断，一直i自增到10的时候，该条件就会返回为false，退出while循环。
二、do-while语句
do-while语句和while循环非常类似，都是while后面的条件判断为true时才会继续循环，所以很多时候两者实现的效果都是一样的，不过，也是有区别的，其区别在于判断表达式执行判断的时间点不一样，do-while语句是先进行执行一遍语句后再执行的判断，这样至少保证循环体代码块执行了一遍，而while 语句是先判断再执行的，如果条件表达式一开始就不成立的话那么循环体代码块就一次也不会被执行。因此有时使用do-while语句是逻辑上必须的。其具体的语法格式如下：
do {
// 语句
}while (判断条件);
上面的格式需要注意的是后面别忘了要添加一个分号(;)，我们也可是使用do-while语句实现上面的输出十句hello world语句的程序，代码如下：
int i=0;//初始化 i为0 do{ System.out.println("hello world"); i++; }while(i<10); System.out.println("while循环结束了。i="+i );
运行结果与使用while循环一样，我们再尝试一下把i改成20，其代码如下：
int i=20;//初始化 i为0 do{ System.out.println("hello world"); i++; }while(i<10); System.out.println("while循环结束了。i="+i );
程序输出了一句hello world后，i自增后就是21了，这个时候条件判断就已经是false，所以程序最后也只输出了一句hello world就退出该循环了。我们也可以使用while循环测试一下，代码如下：
int i=20;//初始化 i为0 while(i<10){//进入循环前先判断条件是否为true System.out.println("hello world!"); i++;//每一次循环结束前i自增1 } System.out.println("while循环结束了。i="+i);
一句hello world语句都没有输出，因为以开始条件就已经是false了，所以循环体一次也没有进入过。这样你能明白while循环和do-while循环之间的使用上的区别了吧。
三、for循环语句
在while循环和do-while循环中我们都使用整型变量i来控制循环次数，每一次执行循环前都需要判断是否满足循环条件，在循环体重都需要让变量i自增，像这种相对明确循环次数，并且频繁使用一个变量来控制循环，java提供了更加简洁，结构根据清晰的循环，就是下面for循环语句，标准的for循环语句分为三段表达式。其具体格式如下：
for(初始化;测试; 增量){
操作语句;
}
我们先看看示例，再详细讲解for的格式，还是实现上面所说的输出10句hello world语句。
for(int i=0;i<10;i++){
System.out.println("hello world!");
}
System.out.println("循环结束了。");
在for后面的小括号一样要包含三句语句，每一个语句的内容不是必须的，但是分号(;)是不可以缺少的。三句语句中第一句是一个表达式，用作声明并初始化，只会执行一次，初始化的通常是一个变量，这个变量作用域循环体内部。当然同时初始化多个变量也是语法所允许的，只是通常没这种必要，比如：
for(int i=0,j=20;i<50;i++){
…
}
第二句负责在每次循环执行之前进行判断，判断返回一个boolean值，根据这个boolean值决定是否继续执行循环，true继续执行，false终止循环。
第三句可以是任意java表达式，而最常见的用法是进行一个递增或者递减的运算，运算的值用于第二个表达式中进行循环控制判断。
每一句都不是必须的，所以最简单的for循环语句就是
for(;;){
...
}
就算没有语句也要写上分号。
for循环控制的{…}大括号内被称为循环体，这段语句块是每次循环时都执行的代码逻辑。下面我们再具几个常见的例子说明以下for循环的应用。比如我们要计算1至100累加的和是多少，当实现这个功能有很多方法，这里我们使用for循环实现它，代码如下：
int sum=0;
for(int i=1;i<=100;i++){
sum+=i;//实现累加
}
System.out.println("sum="+sum);
我们一开始定义了一个变量sum并初始化为0，用于记录运算的结果。sum的作用域不再for循环体里，然后我们使用for循环开始求和，首先我们先写for循环的控制头，在第一句中我们初始化一个整型变量i，该i的作用域仅在循环里使用
int i=0；
然后我们就写循环的条件判断了i必须要小于等100，才能继续进入循环体。
i<=100;
如果条件满足，程序其实就会进入循环体内，执行累加的功能。
sum+=i;//实现累加
循环体执行完毕才会进入循环控制头的第三句代码，这里就是让i自增1。
i++;
程序就是这样不断的循环下去，一至到条件判断为false为止。最后就会退出该循环并输出最后的结果：sum=5050
3.3多重循环和break、continue语句
一、嵌套循环
循环可以互相嵌套，以实现更加复杂的逻辑，其代码的复杂程度也会提高，对初学者而言这应该是个难点，下面我们通过一些例子说明嵌套循环的使用，读者要自己把这些代码上机练习，并理解程序运行的流程。
先看看一个简单例子，代码如下：
//二重循环 for(int i=0;i<3;i++){ for(int j=0;j<2;j++){ System.out.println("i="+i+",j="+j); } }
上面是一个二重循环，因为在for循环里又嵌套了一个循环，当然循环可以无限嵌套，所以也就是有无限重的循环，但是一般我们写代码的时候很少超过三重循环。
在第一层循环中，循环的控制头和上面介绍的没有不同，仅仅只是该循环的循环体里又包含了一个循环，我们需要的是理解这段程序的执行流程：
外层循环i=0时，条件满足进入循环体，并执行第二层循环，
第二层循环是j=0，条件满足进入循环体，并执行里面的输出语句,输出：
i=0,j=0
然后还是第二层的循环还没有结束，继续执行，这个时候j=1，所以输出：
i=0,j=1;
第二层循环结束。
这个时候外层循环还没有结束，i自增1后，又进入循环，并再次执行第二层循环这个时候i=1，又再一次的执行了第二层的循环：
第二层循环是j=0，条件满足进入循环体，并执行里面的输出语句,输出：
i=1,j=0
然后还是第二层的循环还没有结束，继续执行，这个时候j=1，所以输出：
i=1,j=1;
第二层循环结束。
类似的，这个时候外层循环还没有结束，i自增1后，i=2又进入二层循环，所以这个程序最后的输出结果是：
i=0,j=0
i=0,j=1
i=1,j=0
i=1,j=1
i=2,j=0
i=2,j=1
下面我们再具一个稍微复杂一点的程序：输出乘法表。
1×1=2
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
...
1X9 ... ... 9X9=81
实现代码如下：
for(int i=1;i<10;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"X"+i+"="+(i*j)+" ");
}
System.out.println();
}
其读者自己演示和说明其执行流程。
二、break
break与continue语句和都是可以控制循环的执行流程的，其中break语句可以直接强行跳出整个循环，默认情况下直接跳到下一条语句进行执行。比如我们要输出类似下面的三角形星号符。
*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
实现代码如下：
public class Test {
//三角形的高度
// 直角三角形的高度
int hight = 0;
System.out.println("请输入三角形的高度:"); // 提示信息
Scanner scnr = new Scanner(System.in); // 获取控制台输入
hight = scnr.nextInt(); // 在控制台输入中取下一个int值
for (int i = 0; i < hight; i++) { // 按hight的高度一层一层打印
for (int j = 0; j < hight; j++) {
// 每次继续迭代，原则第一层打一个， 第二层打二个，第三层打三个… if (j <= i) {
System.out.print("*"* ");
} else {
// 退出循环的条件，比如在第二层打 第三个是退出
break;
//后面不能写代码了，会提示错误
}
}
System.out.println(); // 每层的换行符
}
读者可以上机演示上面的代码。注意在嵌套循环中break只能跳出自己的循环体，对于父循环体没有任何影响。直接写在break语句后面的代码在Eclipse中会提示错误，因为这些语句具有不可达性。
前面介绍过在java中没有goto语句，但是在循环中使用break语句可以达到类似goto语句的效果，这种用法是在break语句中添加行标号，控制会被传递给当前方法中的带有这一标号的语句，这种格式的写法如下：
break label;
三、continue语句
continue语句语句和break语句一样都是指退出循环，但是区别在于continue特指退出当前一层循环，继续下一层循环的执行。可以认为是continue是对break语句的一种补充机制，提供了终止当前一层循环继续去判断循环控制表达式进而继续执行循环体的可能。Continue跟break类似，同样提供类似goto的功能：
continue toCode;
注意退出循环的方法除了使用break语句/continue语句外，你还可以使用return，return的优先级别非常高，在任何情况下它都会直接终止当前方法的运行。参考下面的示例：
for (int i = 0; i < 3; i++) {
System.out.println("开始第" + i + "次for循环");
if (i == 1) {
continue;//程序运行后面的代码就不会执行，但循环不会退出。
}
System.out.println("看看continue后这里执行了吗？");
}
3.4数组
到目前为止，我们都是使用一个变量就声明一个变量，但是我们我们现在要声明10个整型变量，那么我们是不是需要写10行代码呢？虽然我们可以在一行代码中同时声明多个变量，写10个也不算什么，但是如果要声明50个，或者100个呢！这个时候最好的方法是使用数组组织这些数据了。
一、数组的作用和组织方式
数组是一个可以保存多个相同类型的变量的顺序集合，这些变量在数组中以列表的形式存在，每个信息都对应的有自己的脚标，编程时可以通过数据项的脚标很方便的访问到每个信息。数组类型在创建时需要指定长度，它是固定长度值存储一类信息的集合。
数组的组织方式在物理方式和逻辑方式上都是以顺序表的方式保存的，也就是说如果有一个由10个整型变量组成的数组，那么这10个变量都是存储在相邻的内存区域中，逻辑上也是相邻的。
数组a
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
二、数组的声明和初始化
要使用数组的第一步当然就是声明一个数组，和声明一个变量类似，也需要先写上数组的类型，数组名称的命名规范和变量的命名一样，但是为了和其他的变量的声明相区别，在声明一个数组是需要使用一对中括号([])。
声明一个数组可以这样：
String unames[]; int uages[]; float scores[];
学过C语言的同学应该感动非常熟悉了，但是java也可使用下面这种写法，把中括号前置，其效果是一样的。
String []unames; int []uages; float[] scores; // 中括号前置还是后置的声明是等效的
和声明变量一样，我们也可以在声明的同时初始化内容，也可以声明数组对象的大小，以后在再进行赋值操作。
因为数据也是对象，所以我们可以使用new运算符来直接构造数组对象，并初始化数组的大小。如下面的示例：声明数组，然后使用new关键字例如：
String unames[]; unames=new unames[50];//可以先声明unames数组，再创建数组，指定长度
声明了一个数组名是unames的对象，该对象可以放10个字符串对象。当然，我们也可以在声明的同时创建数组，如下面这个示例：
String unames[] = newString [50]; int[] scores; = new int [50];
new关键字通常的含义是创建对象分配计算机内存空间，当我们使用new创建数组时，java将会自动给基本数据类型的数组赋予初始值，比如int的数组每个位置都是0，boolean的数组每个位置都是true，char的数组每项都是’\0’,如果是对象则给null值。
显示的赋值。
对数组的创建当然也可以同时赋值，这样的语法不使用new关键字，被称作静态初始化数组。比如我们声明一个长度是5的字符串数组:
String unames[] = {“java”, “oracle”, “mysql”,“tomcat”, “jvaScript”};
或：
String unames[] = new unames[]{“java”, “oracle”, “mysql”,“tomcat”, “jvaScript”};
三、数组的访问和操作
我们先声明一个整型变量，并显示为其赋值，其代码如下：
int []a={10,20,30,40,50,60,70,80,90,100};
那么在它内存中的组织方式如下：
| 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 | 100 |
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
由上面可知，数组是顺序存储的，而且每一个数组都有一个下标表示，注意下标由0作为起始数，根据上表可知我们要查找，修改数组里的某个数组可以使用下标来唯一定位一个数。其格式是：
数组名[下标]。
比如我们想打印该数组的第5个数，那么对数组的访问可以使用数据脚本进行：
System.out.println(a[4]);//注意下标从0开始，第5个，下标对应是4。
另外数组还提供了一个属性length 可以获得数组的长度，代码如下：
System.out.println("数组的长度："+a.length);
那么如果我要打印数组的全部类型呢?我们当然不需要写10行语句，可以结合我们上面介绍的循环语句帮帮忙，示例代码如下：
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
这样就可以打印数据的全部类型了，因为数组的下标是以0作为起点的，因此第一个项应该对应a[0]。在a数组中存储信息的项的脚标分别是:0,1,2...9，所以我们就声明了一个整型变量i=0，然后让i不断的累加1，并且i不能大于数组的长度。在遍历数组时，我们常常会用到这样的循环。
明白了数组的访问后，对数组项赋值也就非常简单了。代码如下：
a[9] = 1000;// 数组a的第10个项赋值1000
我们也可以声明一个大小为100的整型数据，并为其赋值1,2,3...100、其代码如下
int []a=new int[100];
for(int i=0;i<a.length;i++){
a[i]=i+1;
}
四、数组的一些示例
在程序中数组使得比较多，为了加深大家对数组的理解，下面举几个简单的示例说明。例子1：已知一组数据 12 ，34，56，78 。在程序定义以上数组，输出数组中最大值。其实现代码如下：
int arr[]={12,34,56,78};
int max=arr[0];
for(int i=1;i<arr.length;i++){
max=max>arr[i]?max:arr[i];
}
System.out.println(max);
程序开始先定了数组和初始化数据，然后定义了一个max变量，该变量保存每一次比较后的较大值，在比较前先把数组的第一个数赋值给该变量，然后通过循环把max保存的值和数组的值逐个数组的值进行比较，每一次比较都把较大值保存在max变量中，这样循环结束后，max保存的就是数组里的最大值了。
例子2：对int arr[]={23,10,39,56,7,8,2,3}从大到小的进行排序,并输出。（冒泡排序）
int arr[]={23,10,39,56,7,8,2,3};
int max;//中间变量
for(int j=0;j<arr.length;j++){
boolean flag=true;//是否还有数据需要交换
for(int i=0;i<arr.length-1-j;i++){
if(arr[i]>arr[i+1]){
//每次两两比较，如果前一个数比后一个数要，那么就交换它们的位置
max=arr[i];
arr[i]=arr[i+1];
arr[i+1]=max;
flag=false;//还有数据需要交换
}
}
//如果没有数据需要交换就可以退出循环
if(flag){
break;
}
//测试每次结果
/*for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.println();*/
}
//测试最后比较的结果
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
这个道题目是使用了冒泡排序的算法，初学者可能比较难理解，有关排序的详细说明我们在后面的章节中专门论述，这里暂不说明了，大家可以先自己理解代码。
五、多维数组
上面介绍都是一维数组，因为数组里的元素都是基本数据类型了，java也可以表示多维数组，但是在内存的物理组织方式还是和一维数组一样的方式保存的，所谓的多维数组的实际就是数组里面又包含一个数组而已。
多维数组在逻辑上的组织方式在我们日常生活中非常常见，比如像Excal表格，就是二维表。我们生活的立体三维世界,使用x、y、z坐标能够精确定位到立体空间所在的位置。在真实世界，多维信息模型非常普遍。但Java 中没有真正的多维数组，只有数组的数组，这样的用法功能上跟多维数组是一样。
excel二维表格：脚标B2的值是5
由于不是真正的多维数组，因此在Java中多维数组不一定是规则矩阵形式，这样其实提供了更加灵活的编码方式。例如我们也可以象一维数组一样，在定义数组的同时就为多维数组元素分配空间并赋值，也就是对多维数组的静态初始化。如下面这句代码：
int arr[]={1,2,3};//一维数组
int arr2[][]={{1},{2},{3}};//二维数组
int arr3[][][]={{{1}},{{2}},{{3}}};//三维数组
三维以上的数组用得比较少，这里我们就以二维数组进行学习，先看看下面的示例代码：
public static void main(String[] args) {
//定义二维数组，并赋值
int arrs[][]={{1,2,3,4},
{5,6,7,8},
{9,10,11,12}};
System.out.println("数组的长度："+arrs.length);
System.out.println("第一行数组的长度"+arrs[0].length);
System.out.println("访问第一行第一列的数据："+arrs[0][0]);
System.out.println("访问第二行第三列的数据："+arrs[1][2]);
//打印
for(int i=0;i<arrs.length;i++){
for(int j=0;j<arrs[i].length;j++){
System.out.print("i="+i+",j="+j+":");
System.out.print(arrs[i][j]+",");
}
System.out.println();
}
}
我们一开始定义了一个二维数组arrs，并为其赋初值，为了代码的可读性更强，我特意每一维代码就换一行，这样我们的二维数组的逻辑结构与下面的表格类似
物理结构其实就是一维数组arrs里面的元素又一个一维数组而已，所以我们可以打印出数组arrs的长度
System.out.println("数组的长度："+arrs.length);
程序输出的结果是3，因为一维数组arrs里面只放了三个元素，只是这三个元素又是一个一维数组。
那么我们也可以从一维数组arrs获得第一个元素（也是一个数组），然后打印该数组的长度：
System.out.println("第一行数组的长度"+arrs[0].length);
程序输出为4，因为该数组只有四个元素，而且是基本元素了。
如果现在我想获得第一个元素，那么我应该如何访问呢？你可以把上面的表格想象成为进入电影院后找座位。你可以根据你电影票上面的第几行和第几列的信息，找到自己的座位，和现实生活不同的地方在于——下标从0开始。所以可以像下面代码一样访问数组里面的元素：
System.out.println("访问第一行第一列的数据："+arrs[0][0]); System.out.println("访问第二行第三列的数据："+arrs[1][2]);
“arrs[0][0]”为什么这样可以访问第一行第一列的数据，其实arrs[0]就是获得第一行的元素，也就是第一维的数组，arrs[0][0]当然也就是第一行第一列的数据了。从这个例子总我们可以理解“数组的数组”的含义，同理去理解三维及更多维度的数组。
接下来我们还把该数组的所有的数组全部打印出来，使用了二重循环，它的运行过程其实就是先获得第一行的数组，然后把第一行的数组通过循环数组打印处理，外层循环在移动到第二行的数组，依次类推，就打印了全部的数组。
//打印 for(int i=0;i<arrs.length;i++){ for(int j=0;j<arrs[i].length;j++){ System.out.print("i="+i+",j="+j+":"); System.out.print(arrs[i][j]+","); } System.out.println(); }
对二维数组的元素修改和赋值和一维数组类似，大家可以自己上机尝试。
727
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
