你的位置:首页 > Java教程

[Java教程]【03


 

 

流程控制与数组


 

 

顺序结构

 

  •顺序结构就是程序从上到下一行一行地执行,中间没有任何判断和跳转。

  •如果main方法多行代码之间没有任何流程控制,则程序总是从上向下依次执行,排在前面的代码先执行,排在后

面的代码后执行。

 


分支结构

 

 

•Java提供了两种常见的分支控制结构:

–if语句:使用布尔表达式或布尔值作为分支条件来进行分支控制。

–switch语句:用于对多个整型值进行匹配,从而实现分支控制。


 

 

 if条件语句

 

•if条件语句的3种形式:

•  ▲ if (logic expression) { statements…}

 

•  ▲ if (logic expression) { statements…}

•       else { statements…}

 

•  ▲ if (logic expression) { statements…}

•       else if (logic expression) { statements…}

•       …//可以有0个或多个else if 语句

•       else { statements…} //最后的else语句也可以省略

 

•注意:if、else、else if 后条件执行体要么是一个花括号括起来的语句块,则这个语句块整体作为条件执行体;

要么是以分号为结束符的一行语句,甚至可能是一个空语句(空语句就是一个分号)。


If语句常见的错误

 

 

•如果if、else、else if后的执行体只有一行语句时,则可以省略花括号,但我们最好不要省略花括号,因为保留花

括号会有更好的可读性,且还可以减少发生错误的可能。

 

•对于if 语句,还有一个很容易出现的逻辑错误,这个逻辑错误并不属于语法问题,但引起错误的可能性更大。如

后面程序TestIfError.java我们想打印的是中年人,但打印出来的结果是青年人。

 

• 对于任何的if else 语句,表面上看起来else后没有任何条件,或者else if后只有一个条件,但这不是真相:因为

else的含义是“否则”,else本身就是一个条件!else 的隐含条件就是对前面条件取反。


 

 switch分支语句

 

 

•可以省略case后代码块的花括号


◆使用break;语句,防止case穿透


◆default可以省略,但不推荐省略


◆switch语句中控制表达式的类型只能是byte、short、char、int、String(JDK7新增)和枚举


 

 Switch语句容易导致的错误

 

 

•switch语句后的expression表达式的数据类型只能是byte、short、char、int、String类型和枚举;

•小心省略了case后代码块的break;时所引入的陷阱。


循环结构 

 

 

•Java支持3种基本的循环语句:

–while 循环语句

–do while 循环语句

– for 循环语句


while  & do while 循环语句

 

 

★ while 循环的语法格式如下:

[init_statements]

while (test_expression)

{          statements;

  [iteration_statements]

}

★ 执行过程:先判断逻辑表达式的值,若为true

则执行其后面的语句,然后再次判断条件并反复

执行,直到条件不成立为止。

 

 


★ do while 循环的语法格式如下:

[init_statements]

do

{    statements;

  [iteration_statements]

}while (test_expression);

 

※注意:do while 循环的循环条件必须有一个分

号,这个分号表明循环结束。

★ 执行过程:先执行语句,再判断逻辑表达式的

值,若为true,再执行语句,否则结束循环

 

 


控制循环条件

 

 

•使用循环时,一定要保证循环条件有变成false的时候,如果循环条件永远为true,那就是死循环。使用while循

  环时还有一个陷阱,while循环条件后紧跟一个分号。

 

•do while 循环语句里,即使test_expression循环条件的值开始是假,do while循环也会执行循环体。因此,

  do while循环的循环体至少执行一次。


本文原创作者:pipi-changing

本文原创出处:http://www.cnblogs.com/pipi-changing/

 


 

for 循环语句

 

 

•for ([inint_statements] ; [test_expression] ; [iteration_statements]){  statements  }

 

•★ 执行过程:首先计算表达式1,即init_statements,接着执行表达式2,即test_expression,若表达式2的

值为true,则执行语句(statements),接着执行表达式3,即iteration_statements,再判断表达式2的值;

依次重复下去,直到表达式的值=false,则结束for循环。因此,for循环的循环条件(表达式2)比循环体(语

句)要多执行一次。

 

•注意:for循环的循环迭代语句并没有与循环体放在一起,因此即使在执行循环体时遇到continue语句结束本次

循环,循环迭代语句一样会得到执行。


for循环指定多个初始化语句

 

 

•for 循环允许同时指定多个初始化语句,循环条件也可以是一个包含逻辑运算符的表达式。但只能有一个声明语

  句,因此如果需要在初始化表达式中声明多个变量,那么这些变量应该有相同的数据类型。

 

•初学者使用for循环时也容易犯一个错误,他们以为只要在for后的括号内控制了循环循环迭代语句就万无一失,

  但实际情况则不是这样的。


for循环的分号

 

 

•for 循环圆括号中只有两个分号是必须的,初始化语句、循环条件、迭代语句部分都可以省略,如果省略了循环

  条件,则这个循环条件默认是true,将会产生一个死循环。

 

•使用for循环时,还可以把初始化条件定义在循环体之外,把循环迭代语句放在循环体内,这种做法将非常类似前

  面的while循环。


嵌套循环

 

 

•各种基本类型的循环都可以作为外层循环,各种基本类型的循环也可以作为内层循环。

•假设外层循环的循环次数为n次,内层循环的循环次数为m次,那么内层循环的循环体实际上需要执行n*m次。

•实际上,嵌套循环不仅可以是两层嵌套,还可以是三层嵌套,四层嵌套……


break语句

 

 

•break用于完全结束一个循环,跳出循环体。不管是哪种循环,一旦在循环体中遇到break,系统将完全结束循

  环,开始执行循环之后的代码。

 

•break不仅可以结束其所在的循环,还可结束其外层循环。此时需要在break后紧跟一个标签,这个标签用于标

识一个外层循环。Java中的标签就是一个紧跟着英文冒号(:)的标识符。且它必须放在循环语句之前才有作用。


continue 语句

 

 

•continue的功能和break有点类似,区别是continue只是中止本次循环,接着开始下一次循环。而break则是

完全中止循环。


return语句

 

 

• return关键字并不是专门用于跳出循环的,return的功能是结束一个方法。

 

•一旦在循环体内执行到一个return语句,return语句将会结束该方法,循环自然也随之结束。与continue和

break不同的是,return直接结束整个方法,不管这个return处于多少层循环之内。


数组类型

 

 

•在任何已有类型后加上方括号[ ],又变成一种新类型,这种类型统称为数组类型,所有的数组类型又称为引用类

型,所以又称引用类型。

 

•Java的数组要求所有数组元素具有相同的数据类型。因此,在一个数组中,数组元素的类型是唯一的,即一个数

组里只能存储一种数据类型的数据,而不能存储多种数据类型的数据。

 

•一旦数组的初始化完成,数组在内存中所占的空间将被固定下来,因此数组的长度将不可改变。即使把某个数组

元素的数据清空,但它所占的空间依然被保留,依然属于该数组,数组的长度依然不变。

 

•Java的数组既可以存储基本类型的数据,也可以存储引用类型的数据。

 

•值得指出的是:数组也是一种数据类型,它本身是一种引用类型。


定义数组

 

 

•Java语言支持两种语法格式来定义数组:

–type[ ] arrayName;

–type  arrayName[ ];

•对于这两种语法格式,一般推荐使用第一种格式。因为第一种格式不仅具有更好的语意,也具有更好的可读性。

•数组是一种引用类型的变量,因此使用它定义一个变量时,仅仅表示定义了一个引用变量(也就是定义了一个指

  针),这个引用变量还未指向任何有效的内存,因此定义数组时不能指定数组的长度。

 

•※注意:定义数组时不能指定数组的长度。


数组的初始化

 

 

•静态初始化:初始化时由程序员显式指定每个数组的初始值,由系统决定需要的数组长度。

•动态初始化:初始化时程序员指定数组长度,由系统为数组元素分配初始值


动态初始化

 

 

•arrayName = new type[ length];


在上面的语法中,需要指定一个int整型的length参数,这个参数指定了数组的长度,也就是可以容纳数组元素的

个数。


使用数组

 

 

•数组最常用的用法就是访问数组元素,包括对数组元素赋值和访问数组元素的值,访问数组元素是通过在数组引用变

量后紧跟一个方括号([ ]),方括号里是数组元素的索引值。

 

•Java语言的数组索引是从0开始的,也就是说,第一个数组元素的索引值为0,最后一个数组元素的索引为数组长度

减1。

 

•如果访问数组元素进指定的索引小于0,或者大于等于数组的长度,编译程序不会出现任何错误,但运行时出现异

常:java.lang.ArrayIndexOutOfBoundsException:2(数组索引越界异常),在这个异常提示信息后有一个int

整数,这个整数就是程序员试图访问的数组索引。

 

•所有数组都提供了一个length属性,通过这个属性可以访问到数组的长度,一旦获得了数组的长度后,就可以通过循

环来遍历该数组的每个数组元素。


 JDK1.5 提供了foreach循环

 

 

•从JDK1.5 之后,Java提供了一种更简单的循环:foreach循环,这种循环遍历数组和集合更加简洁。使用

foreach循环遍历数组和集合元素时,无须获得数组和集合长度,无须根据索引来访问数组元素和集合元素,

foreach循环自动遍历数组和集合的每个元素。

 

•当使用foreach循环来迭代输出数组元素或集合时,通常不要对循环变量进行赋值,虽然这种赋值在语法上是允

许的,但没有太大的意义,而且极容易引起错误。


深入数组

 

 

•数组元素和数组变量在内存里是分开存放的。


实际的数组元素是存储在堆(heap)内存中;数组引用变量是一个引用类型的变量,被存储在栈(stack)内存

中。

 

 

•如果堆内存中数组不再有任何引用变量指向自己,则这个数组将成为垃圾,该数组所占的内存将会被系统的垃圾

回收机制回收。因此,为了让垃圾回收机制回收一个数组所占的内存空间,则可以将该数组变量赋为null,也就切

断了数组引用变量和实际数组之间的引用关系,实际数组也就成了垃圾。


 

 数组长度不可变

 

 

•只要类型相互兼容,可以让一个数组变量指向另一个实际的数组,这种操作会产生数组的长度可变的错觉。

•但由于数组变量整体赋值导致的数组的长度可以改变,只是一个假相。


基本类型数组的初始化

 

 

•对于基本类型数组而言,数组元素的值直接存储在对应的数组元素中,因此,初始化数组时,先为该数组分配内

存空间,然后直接将数组元素的值存入对应数组元素中,

public class TestPrimitiveArray{  public static void main(String[] args)  {    // 定义一个int[ ]类型的数组变量    int[] iArr;    // 动态初始化数组,数组长度为5    iArr = new int[5];    // 采用循环方式为每个数组元素赋值    for (int i = 0; i < iArr.length; i++)    {      iArr[i] = i + 10;      System.out.println(iArr[i]);    }  }}

TestPrimitiveArray

 

 

 

 

 


 

 引用类型数组的初始化

 

 

引用类型数组的数组元素是引用,因此情况变得更加复杂:每个数组元素里存储的还是引用,它指向另一块内存,

这块内存里存储了有效数据。


没有多维数组

         

 

•Java语言提供了多维数组的语法,但多维数组实质上还是一维数组。


Java语言里的数组类型是引用类型,因此,数组变量其实是一个引用,这个引用指向真实的数组内存。数组元素

的类型也可以是引用,如果数组元素的引用再次指向真实的数组内存,这种情形看上去很像多维数组。

 

•定义二维数组的语法:

•type[ ] [ ]  arrName;


 

public class TestTwoDimension {  public static void main(String[] args) {    // 定义一个二维数组    int[][] a;    // 把a当成一维数组进行初始化,初始化a是一个长度为3的整数    // a数组的数组元素又是引用类型    a = new int[3][];    // 把a数组当成一维数组,遍历a数组的每个元素    for (int i = 0; i < a.length; i++) {      System.out.println(a[i]);    }    // 初始化a数组的第一个元素    a[0] = new int[2];    // 访问a数组的第一个元素所指数组的第二个元素    a[0][1] = 6;    // a数组的第一个元素是一个一维数组,遍历这个一维数组    for (int i = 0; i < a[0].length; i++) {      System.out.println(a[0][i]);    }  }//  null//  null//  null//  0//  6}

TestTwoDimension

我们可以得到一个结论:

 

二维数组是一维数组,其数组元素是一维数组;三维数组也是一维数组,其数组元素是二维数组;四维数组还是一维数

组,其数组元素是三维数组……从这个角度来看,Java语言里没有多维数组。

 


 

 Java 8增强的Arrays工具类

 

 

•Arrays类里包含的一些static修饰的方法可以直接操作数组。

•Java 8增强了Arrays类的功能,Java 8为Arrays类增加了一些工具方法,这些工具方法可以充分利用多CPU并

行的能力来提高设值、排序的性能。


 

代码区: 

 

public class IfCorrectTest {  public static void main(String[] args) {    int age = 45;    if (age > 60) {      System.out.println("老年人");    } else if (age > 40) {      System.out.println("中年人");    } else if (age > 20) {      System.out.println("青年人");    }  }//  中年人}

IfCorrectTest
public class IfCorrectTest2 {  public static void main(String[] args) {    int age = 45;    if (age > 60) {      System.out.println("老年人");    }    // 在原本的if条件中增加了else的隐含条件    if (age > 40 && !(age > 60)) {      System.out.println("中年人");    }    // 在原本的if条件中增加了else的隐含条件    if (age > 20 && !(age > 60) && !(age > 40 && !(age > 60))) {      System.out.println("青年人");    }  }//  中年人}

IfCorrectTest2
public class IfErrorTest {  public static void main(String[] args) {    int age = 45;    if (age > 20) {      System.out.println("青年人");    } else if (age > 40) {      System.out.println("中年人");    } else if (age > 60) {      System.out.println("老年人");    }  }//  青年人}

IfErrorTest
public class IfErrorTest2 {  public static void main(String[] args) {    int age = 45;    if (age > 20) {      System.out.println("青年人");    }    // 在原本的if条件中增加了else的隐含条件    if (age > 40 && !(age > 20)) {      System.out.println("中年人");    }    // 在原本的if条件中增加了else的隐含条件    if (age > 60 && !(age > 20) && !(age > 40 && !(age > 20))) {      System.out.println("老年人");    }  }//  青年人}

IfErrorTest2
public class IfTest {  public static void main(String[] args) {    int age = 30;    if (age > 20)    // 只有当age > 20时,下面花括号括起来的语句块才会执行    // 花括号括起来的语句是一个整体,要么一起执行,要么一起不会执行    {      System.out.println("年龄已经大于20岁了");      System.out.println("20岁以上的人应该学会承担责任...");    }    // 定义变量a ,并为其赋值    int a = 5;    if (a > 4)      // 如果a>4,执行下面的执行体,只有一行代码作为代码块      System.out.println("a大于4");    else      // 否则,执行下面的执行体,只有一行代码作为代码块      System.out.println("a不大于4");    // 定义变量b ,并为其赋值    int b = 5;    if (b > 4)      // 如果b>4,执行下面的执行体,只有一行代码作为代码块      System.out.println("b大于4");    else      // 否则,执行下面的执行体,只有一行代码作为代码块      b--;    // 对于下面代码而言,它已经不再是条件执行体的一部分,因此总会执行。    System.out.println("b不大于4");    // 定义变量c ,并为其赋值    int c = 5;    if (c > 4)      // 如果b>4,执行下面的执行体,将只有c--;一行代码为条件体      c--;    // 下面是一行普通代码,不属于条件体    System.out.println("c大于4");    // 此处的else将没有if语句,因此编译出错。    // else    // 否则,执行下面的执行体,只有一行代码作为代码块    System.out.println("c不大于4");  }//  年龄已经大于20岁了//  20岁以上的人应该学会承担责任...//  a大于4//  b大于4//  b不大于4//  c大于4//  c不大于4}

IfTest
public class StringSwitchTest {  public static void main(String[] args) {    // 声明变量season    String season = "夏天";    // 执行swicth分支语句    switch (season) {    case "春天":      System.out.println("春暖花开.");      break;    case "夏天":      System.out.println("夏日炎炎.");      break;    case "秋天":      System.out.println("秋高气爽.");      break;    case "冬天":      System.out.println("冬雪皑皑.");      break;    default:      System.out.println("季节输入错误");    }  }//  夏日炎炎.}

StringSwitchTest
public class SwitchTest {  public static void main(String[] args) {    // 声明变量score,并为其赋值为'C'    char score = 'C';    // 执行swicth分支语句    switch (score) {    case 'A':      System.out.println("优秀");      break;    case 'B':      System.out.println("良好");      break;    case 'C':      System.out.println("中");      break;    case 'D':      System.out.println("及格");      break;    case 'F':      System.out.println("不及格");      break;    default:      System.out.println("成绩输入错误");    }  }//  中}

SwitchTest

 

 

public class WhileTest {  public static void main(String[] args) {    // // 循环的初始化条件    // int count = 0;    // // 当count小于10时,执行循环体    // while (count < 10)    // {    // System.out.println(count);    // // 迭代语句    // count++;    // }    // System.out.println("循环结束!");    // // 下面是一个死循环    // int count = 0;    // while (count < 10)    // {    // System.out.println("不停执行的死循环 " + count);    // count--;    // }    // System.out.println("永远无法跳出的循环体");    int count = 0;    // while后紧跟一个分号,表明循环体是一个分号(空语句)    while (count < 10)      ;    // 下面的代码块与while循环已经没有任何关系    {      System.out.println("------" + count);      count++;    }  }}

WhileTest
public class DoWhileTest {  public static void main(String[] args) {    // 定义变量count    int count = 1;    // 执行do while循环    do {      System.out.println(count);      // 循环迭代语句      count++;      // 循环条件紧跟while关键字    } while (count < 10);    System.out.println("循环结束!");    // 定义变量count2    int count2 = 20;    // 执行do while循环    do      // 这行代码把循环体和迭代部分合并成了一行代码      System.out.println(count2++);    while (count2 < 10);    System.out.println("循环结束!");  }//  1//  2//  3//  4//  5//  6//  7//  8//  9//  循环结束!//  20//  循环结束!}

DoWhileTest
public class ForErrorTest {  public static void main(String[] args) {    // 循环的初始化条件,循环条件,循环迭代语句都在下面一行    for (int count = 0; count < 10; count++) {      System.out.println(count);      // 再次修改了循环变量      count *= 0.1;    }    System.out.println("循环结束!");  }}

ForErrorTest
public class ForInsteadWhile {  public static void main(String[] args) {    // 把for循环的初始化条件提出来独立定义    int count = 0;    // for循环里只放循环条件    for (; count < 10;) {      System.out.println(count);      // 把循环迭代部分放在循环体之后定义      count++;    }    System.out.println("循环结束!");    // 此处将还可以访问count变量  }//  0//  1//  2//  3//  4//  5//  6//  7//  8//  9//  循环结束!}

ForInsteadWhile
public class ForTest {  public static void main(String[] args) {    // 循环的初始化条件,循环条件,循环迭代语句都在下面一行    for (int count = 0; count < 10; count++) {      System.out.println(count);    }    System.out.println("循环结束!");  }//  0//  1//  2//  3//  4//  5//  6//  7//  8//  9//  循环结束!}

ForTest
public class ForTest2 {  public static void main(String[] args) {    // 同时定义了三个初始化变量,使用&&来组合多个boolean表达式    for (int b = 0, s = 0, p = 0; b < 10 && s < 4 && p < 10; p++) {      System.out.println(b++);      System.out.println(++s + p);    }  }//  0//  1//  1//  3//  2//  5//  3//  7}

ForTest2
public class NestedLoopTest {  public static void main(String[] args) {    // 外层循环    for (int i = 0; i < 5; i++) {      // 内层循环      for (int j = 0; j < 3; j++) {        System.out.println("i的值为:" + i + " j的值为:" + j);      }    }  }//  i的值为:0 j的值为:0//  i的值为:0 j的值为:1//  i的值为:0 j的值为:2//  i的值为:1 j的值为:0//  i的值为:1 j的值为:1//  i的值为:1 j的值为:2//  i的值为:2 j的值为:0//  i的值为:2 j的值为:1//  i的值为:2 j的值为:2//  i的值为:3 j的值为:0//  i的值为:3 j的值为:1//  i的值为:3 j的值为:2//  i的值为:4 j的值为:0//  i的值为:4 j的值为:1//  i的值为:4 j的值为:2}

NestedLoopTest
public class WhileTest {  public static void main(String[] args) {    // // 循环的初始化条件    // int count = 0;    // // 当count小于10时,执行循环体    // while (count < 10)    // {    // System.out.println(count);    // // 迭代语句    // count++;    // }    // System.out.println("循环结束!");    // // 下面是一个死循环    // int count = 0;    // while (count < 10)    // {    // System.out.println("不停执行的死循环 " + count);    // count--;    // }    // System.out.println("永远无法跳出的循环体");    int count = 0;    // while后紧跟一个分号,表明循环体是一个分号(空语句)    while (count < 10)      ;    // 下面的代码块与while循环已经没有任何关系    {      System.out.println("------" + count);      count++;    }  }}

WhileTest

 

 

 

 

public class BreakTest {  public static void main(String[] args) {    // 一个简单的for循环    for (int i = 0; i < 10; i++) {      System.out.println("i的值是" + i);      if (i == 2) {        // 执行该语句时将结束循环        break;      }    }  }//  i的值是0//  i的值是1//  i的值是2}

BreakTest
public class BreakTest2 {  public static void main(String[] args) {    // 外层循环,outer作为标识符    outer: for (int i = 0; i < 5; i++) {      // 内层循环      for (int j = 0; j < 3; j++) {        System.out.println("i的值为:" + i + " j的值为:" + j);        if (j == 1) {          // 跳出outer标签所标识的循环。          break outer;        }      }    }  }//  i的值为:0 j的值为:0//  i的值为:0 j的值为:1}

BreakTest2
public class ContinueTest {  public static void main(String[] args) {    // 一个简单的for循环    for (int i = 0; i < 3; i++) {      System.out.println("i的值是" + i);      if (i == 1) {        // 忽略本次循环的剩下语句        continue;      }      System.out.println("continue后的输出语句");    }  }//  i的值是0//  continue后的输出语句//  i的值是1//  i的值是2//  continue后的输出语句}

ContinueTest
public class ContinueTest2 {  public static void main(String[] args) {    // 外层循环    outer: for (int i = 0; i < 5; i++) {      // 内层循环      for (int j = 0; j < 3; j++) {        System.out.println("i的值为:" + i + " j的值为:" + j);        if (j == 1) {          // 忽略outer标签所指定的循环中本次循环所剩下语句。          continue outer;        }      }    }  }//  i的值为:0 j的值为:0//  i的值为:0 j的值为:1//  i的值为:1 j的值为:0//  i的值为:1 j的值为:1//  i的值为:2 j的值为:0//  i的值为:2 j的值为:1//  i的值为:3 j的值为:0//  i的值为:3 j的值为:1//  i的值为:4 j的值为:0//  i的值为:4 j的值为:1}

ContinueTest2
public class ReturnTest {  public static void main(String[] args) {    // 一个简单的for循环    for (int i = 0; i < 3; i++) {      System.out.println("i的值是" + i);      if (i == 1) {        return;      }      System.out.println("return后的输出语句");    }  }//  i的值是0//  return后的输出语句//  i的值是1}

ReturnTest

 

 

 

 

public class ArrayTest {  public static void main(String[] args) {    // 定义一个int数组类型的变量,变量名为intArr.    int[] intArr;    // 使用静态初始化,初始化数组时只指定数组元素的初始值,不指定数组长度。    intArr = new int[] { 5, 6, 8, 20 };    // 定义一个Object数组类型的变量,变量名为objArr.    Object[] objArr;    // 使用静态初始化,初始化数组时数组元素的类型是    // 定义数组时所指定的数组元素类型的子类    objArr = new String[] { "Java", "李" };    Object[] objArr2;    // 使用静态初始化    objArr2 = new Object[] { "Java", "李" };    // 数组的定义和初始化同时完成,使用简化的静态初始化写法    int[] a = { 5, 6, 7, 9 };    // 数组的定义和初始化同时完成,使用动态初始化语法    int[] prices = new int[5];    // 数组的定义和初始化同时完成,初始化数组时元素的类型是定义数组时元素类型的子类    Object[] books = new String[4];    // 输出objArr数组的第二个元素,将输出字符串"李"    System.out.println(objArr[1]);    // 为objArr2的第一个数组元素赋值    objArr2[0] = "Spring";    // 访问数组元素指定的索引等于数组长度,所以下面代码将在运行时出现异常    // System.out.println(objArr2[2]);    // 使用循环输出prices数组的每个数组元素的值    for (int i = 0; i < prices.length; i++) {      System.out.println(prices[i]);    }    // 对动态初始化后的数组元素进行赋值    books[0] = "Java讲义";    books[1] = "轻量级Java EE企业应用实战";    // 使用循环输出books数组的每个数组元素的值    for (int i = 0; i < books.length; i++) {      System.out.println(books[i]);    }  }//  李//  0//  0//  0//  0//  0//  Java讲义//  轻量级Java EE企业应用实战//  null//  null}

ArrayTest
public class ForEachErrorTest {  public static void main(String[] args) {    String[] books = { "轻量级Java EE企业应用实战", "疯狂Java讲义", "疯狂Android讲义" };    // 使用foreach循环来遍历数组元素,其中book将会自动迭代每个数组元素    for (String book : books) {      book = "疯狂Ajax讲义";      System.out.println(book);    }    System.out.println(books[0]);  }//  疯狂Ajax讲义//  疯狂Ajax讲义//  疯狂Ajax讲义//  轻量级Java EE企业应用实战}

ForEachErrorTest
public class ForEachTest {  public static void main(String[] args) {    String[] books = { "轻量级Java EE企业应用实战", "疯狂Java讲义", "疯狂Android讲义" };    // 使用foreach循环来遍历数组元素,    // 其中book将会自动迭代每个数组元素    for (String book : books) {      System.out.println(book);    }  }//  轻量级Java EE企业应用实战//  疯狂Java讲义//  疯狂Android讲义}

ForEachTest
public class ArrayInRam {  public static void main(String[] args) {    // 定义并初始化数组,使用静态初始化    int[] a = { 5, 7, 20 };    // 定义并初始化数组,使用动态初始化    int[] b = new int[4];    // 输出b数组的长度    System.out.println("b数组的长度为:" + b.length);    // 循环输出a数组的元素    for (int i = 0, len = a.length; i < len; i++) {      System.out.println(a[i]);    }    // 循环输出b数组的元素    for (int i = 0, len = b.length; i < len; i++) {      System.out.println(b[i]);    }    // 因为a是int[]类型,b也是int[]类型,所以可以将a的值赋给b。    // 也就是让b引用指向a引用指向的数组    b = a;    // 再次输出b数组的长度    System.out.println("b数组的长度为:" + b.length);  }//  b数组的长度为:4//  5//  7//  20//  0//  0//  0//  0//  b数组的长度为:3}

ArrayInRam
public class ArraysTest {  public static void main(String[] args) {    // 定义一个a数组    int[] a = new int[] { 3, 4, 5, 6 };    // 定义一个a2数组    int[] a2 = new int[] { 3, 4, 5, 6 };    // a数组和a2数组的长度相等,每个元素依次相等,将输出true    System.out.println("a数组和a2数组是否相等:" + Arrays.equals(a, a2));    // 通过复制a数组,生成一个新的b数组    int[] b = Arrays.copyOf(a, 6);    System.out.println("a数组和b数组是否相等:" + Arrays.equals(a, b));    // 输出b数组的元素,将输出[3, 4, 5, 6, 0, 0]    System.out.println("b数组的元素为:" + Arrays.toString(b));    // 将b数组的第3个元素(包括)到第5个元素(不包括)赋为1    Arrays.fill(b, 2, 4, 1);    // 输出b数组的元素,将输出[3, 4, 1, 1, 0, 0]    System.out.println("b数组的元素为:" + Arrays.toString(b));    // 对b数组进行排序    Arrays.sort(b);    // 输出b数组的元素,将输出[0, 0, 1, 1, 3, 4]    System.out.println("b数组的元素为:" + Arrays.toString(b));  }//  a数组和a2数组是否相等:true//  a数组和b数组是否相等:false//  b数组的元素为:[3, 4, 5, 6, 0, 0]//  b数组的元素为:[3, 4, 1, 1, 0, 0]//  b数组的元素为:[0, 0, 1, 1, 3, 4]}

ArraysTest
public class ArraysTest2 {  public static void main(String[] args) {    int[] arr1 = new int[] { 3, -4, 25, 16, 30, 18 };    // 对数组arr1进行并发排序    Arrays.parallelSort(arr1);    System.out.println(Arrays.toString(arr1));    int[] arr2 = new int[] { 3, -4, 25, 16, 30, 18 };    Arrays.parallelPrefix(arr2, new IntBinaryOperator() {      // left代表数组中前一个所索引处的元素,计算第一个元素时,left为1      // right代表数组中当前索引处的元素      public int applyAsInt(int left, int right) {        return left * right;      }    });    System.out.println(Arrays.toString(arr2));    int[] arr3 = new int[5];    Arrays.parallelSetAll(arr3, new IntUnaryOperator() {      // operand代表正在计算的元素索引      public int applyAsInt(int operand) {        return operand * 5;      }    });    System.out.println(Arrays.toString(arr3));  }}

ArraysTest2
public class Gobang {  // 定义棋盘的大小  private static int BOARD_SIZE = 15;  // 定义一个二维数组来充当棋盘  private String[][] board;  public void initBoard() {    // 初始化棋盘数组    board = new String[BOARD_SIZE][BOARD_SIZE];    // 把每个元素赋为"╋",用于在控制台画出棋盘    for (int i = 0; i < BOARD_SIZE; i++) {      for (int j = 0; j < BOARD_SIZE; j++) {        board[i][j] = "╋";      }    }  }  // 在控制台输出棋盘的方法  public void printBoard() {    // 打印每个数组元素    for (int i = 0; i < BOARD_SIZE; i++) {      for (int j = 0; j < BOARD_SIZE; j++) {        // 打印数组元素后不换行        System.out.print(board[i][j]);      }      // 每打印完一行数组元素后输出一个换行符      System.out.print("\n");    }  }  public static void main(String[] args) throws Exception {    Gobang gb = new Gobang();    gb.initBoard();    gb.printBoard();    // 这是用于获取键盘输入的方法    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));    String inputStr = null;    // br.readLine():每当在键盘上输入一行内容按回车,用户刚输入的内容将被br读取到。    while ((inputStr = br.readLine()) != null) {      // 将用户输入的字符串以逗号(,)作为分隔符,分隔成2个字符串      String[] posStrArr = inputStr.split(",");            // 将2个字符串转换成用户下棋的座标      int xPos = Integer.parseInt(posStrArr[0]);      int yPos = Integer.parseInt(posStrArr[1]);      // 把对应的数组元素赋为"●"。      gb.board[yPos - 1][xPos - 1] = "●";      /*       * 电脑随机生成2个整数,作为电脑下棋的座标,赋给board数组。 还涉及 1.座标的有效性,只能是数字,不能超出棋盘范围       * 2.如果下的棋的点,不能重复下棋。 3.每次下棋后,需要扫描谁赢了       */      gb.printBoard();      System.out.println("请输入您下棋的座标,应以x,y的格式:");    }  }//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋//  ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋}

Gobang
public class Num2Rmb {  private String[] hanArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",      "玖" };  private String[] unitArr = { "十", "百", "千" };  /**   * 把一个浮点数分解成整数部分和小数部分字符串   *   * @param num   *      需要被分解的浮点数   * @return 分解出来的整数部分和小数部分。第一个数组元素是整数部分,第二个数组元素是小数部分。   */  private String[] divide(double num) {    // 将一个浮点数强制类型转换为long,即得到它的整数部分    long zheng = (long) num;    // 浮点数减去整数部分,得到小数部分,小数部分乘以100后再取整得到2位小数    long xiao = Math.round((num - zheng) * 100);    // 下面用了2种方法把整数转换为字符串    return new String[] { zheng + "", String.valueOf(xiao) };  }  /**   * 把一个四位的数字字符串变成汉字字符串   *   * @param numStr   *      需要被转换的四位的数字字符串   * @return 四位的数字字符串被转换成的汉字字符串。   */  private String toHanStr(String numStr) {    String result = "";    int numLen = numStr.length();    // 依次遍历数字字符串的每一位数字    for (int i = 0; i < numLen; i++) {      // 把char型数字转换成的int型数字,因为它们的ASCII码值恰好相差48      // 因此把char型数字减去48得到int型数字,例如'4'被转换成4。      int num = numStr.charAt(i) - 48;      // 如果不是最后一位数字,而且数字不是零,则需要添加单位(千、百、十)      if (i != numLen - 1 && num != 0) {        result += hanArr[num] + unitArr[numLen - 2 - i];      }      // 否则不要添加单位      else {        result += hanArr[num];      }    }    return result;  }  public static void main(String[] args) {    Num2Rmb nr = new Num2Rmb();    // 测试把一个浮点数分解成整数部分和小数部分    System.out.println(Arrays.toString(nr.divide(236711125.123)));    // 测试把一个四位的数字字符串变成汉字字符串    System.out.println(nr.toHanStr("609"));  }//  [236711125, 12]//      陆百零玖}

Num2Rmb
public class Num2Rmb {  private String[] hanArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",      "玖" };  private String[] unitArr = { "十", "百", "千" };  /**   * 把一个浮点数分解成整数部分和小数部分字符串   *   * @param num   *      需要被分解的浮点数   * @return 分解出来的整数部分和小数部分。第一个数组元素是整数部分,第二个数组元素是小数部分。   */  private String[] divide(double num) {    // 将一个浮点数强制类型转换为long,即得到它的整数部分    long zheng = (long) num;    // 浮点数减去整数部分,得到小数部分,小数部分乘以100后再取整得到2位小数    long xiao = Math.round((num - zheng) * 100);    // 下面用了2种方法把整数转换为字符串    return new String[] { zheng + "", String.valueOf(xiao) };  }  /**   * 把一个四位的数字字符串变成汉字字符串   *   * @param numStr   *      需要被转换的四位的数字字符串   * @return 四位的数字字符串被转换成的汉字字符串。   */  private String toHanStr(String numStr) {    String result = "";    int numLen = numStr.length();    // 依次遍历数字字符串的每一位数字    for (int i = 0; i < numLen; i++) {      // 把char型数字转换成的int型数字,因为它们的ASCII码值恰好相差48      // 因此把char型数字减去48得到int型数字,例如'4'被转换成4。      int num = numStr.charAt(i) - 48;      // 如果不是最后一位数字,而且数字不是零,则需要添加单位(千、百、十)      if (i != numLen - 1 && num != 0) {        result += hanArr[num] + unitArr[numLen - 2 - i];      }      // 否则不要添加单位      else {        result += hanArr[num];      }    }    return result;  }  public static void main(String[] args) {    Num2Rmb nr = new Num2Rmb();    // 测试把一个浮点数分解成整数部分和小数部分    System.out.println(Arrays.toString(nr.divide(236711125.123)));    // 测试把一个四位的数字字符串变成汉字字符串    System.out.println(nr.toHanStr("609"));  }//  [236711125, 12]//      陆百零玖}

Num2Rmb
public class PrimitiveArrayTest {  public static void main(String[] args) {    // 定义一个int[]类型的数组变量    int[] iArr;    // 动态初始化数组,数组长度为5    iArr = new int[5];    // 采用循环方式为每个数组元素赋值。    for (int i = 0; i < iArr.length; i++) {      iArr[i] = i + 10;    }  }}

PrimitiveArrayTest
class Person {  public int age; // 年龄  public double height; // 身高  // 定义一个info方法  public void info() {    System.out.println("我的年龄是:" + age + ",我的身高是:" + height);  }  // 我的年龄是:16,我的身高是:161.0  // 我的年龄是:16,我的身高是:161.0}public class ReferenceArrayTest {  public static void main(String[] args) {    // 定义一个students数组变量,其类型是Person[]    Person[] students;    // 执行动态初始化    students = new Person[2];    // 创建一个Person实例,并将这个Person实例赋给zhang变量    Person zhang = new Person();    // 为zhang所引用的Person对象的age、height赋值    zhang.age = 15;    zhang.height = 158;    // 创建一个Person实例,并将这个Person实例赋给lee变量    Person lee = new Person();    // 为lee所引用的Person对象的age、height赋值    lee.age = 16;    lee.height = 161;    // 将zhang变量的值赋给第一个数组元素    students[0] = zhang;    // 将lee变量的值赋给第二个数组元素    students[1] = lee;    // 下面两行代码的结果完全一样,因为lee    // 和students[1]指向的是同一个Person实例。    lee.info();    students[1].info();  }}

Person
public class TwoDimensionTest {  public static void main(String[] args) {    // 定义一个二维数组    int[][] a;    // 把a当成一维数组进行初始化,初始化a是一个长度为4的数组    // a数组的数组元素又是引用类型    a = new int[4][];    // 把a数组当成一维数组,遍历a数组的每个数组元素    for (int i = 0, len = a.length; i < len; i++) {      System.out.println(a[i]);    }    // 初始化a数组的第一个元素    a[0] = new int[2];    // 访问a数组的第一个元素所指数组的第二个元素    a[0][1] = 6;    // a数组的第一个元素是一个一维数组,遍历这个一维数组    for (int i = 0, len = a[0].length; i < len; i++) {      System.out.println(a[0][i]);    }    // 同时初始化二维数组的2个维数    int[][] b = new int[3][4];    // 使用静态初始化的语法来初始化一个二维数组    String[][] str1 = new String[][] { new String[3],        new String[] { "hello" } };    // 使用简化的静态初始化语法来初始化二维数组    String[][] str2 = { new String[3], new String[] { "hello" } };    System.out.println(str1[1][0]);    System.out.println(str2[1][0]);  }//  null//  null//  null//  null//  0//  6//  hello//  hello}

TwoDimensionTest