顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转。

分支结构

if条件语句

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

    第一种形式：if（logic expression）{statement...}  第二种形式： if（logic expression）{statement...}  else{statement...}  第三种形式：if（logic expression）{statement...}  else if（logic expression）{statement...}   ...//    可以有两个或多个else if语句      else//   最后的else语句也可以省略{statement...} 

花括号括起来的多行代码称为代码块，一个代码块通常被当成一个整体来执行（除非运行过程中遇到return、break、continue等关键字，或者遇到了异常）。以上代码块又称为条件执行体

if、else、else if后的条件执行体要么是一个花括号括起来的代码块，则这个代码块整体作为条件执行体；要么是以分号为结束符的一行语句，甚至可能是一个空语句（空语句是一个分号），那么就只是这条语句作为条件执行体。如果省略了if条件后条件执行体的花括号，那么if条件只控制到紧跟该条件语句的第一个分号处

使用if...else语句时，优先处理包含范围更小的情况

switch分支语句

switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种整数类型、枚举类型和java.lang.String类型，不能的boolean类型

switch（expression）
{case condition1:{statement（s）break;}case condition2:{statement（s）break;}...case conditionN:{statement（s）break;}default:{statement（s）}
}

允许switch语句的控制表达式是jaca.lang.String类型的变量或者表达式，不能是StringBuffer或StringBuilder这两种字符串类型。

循环结构

循环语句可能包括如下4个部分
初始化语句、循环条件、循环体、迭代语句

建议不要在循环体内修改循环变量（循环计数器）的值，否则会增加程序出错的可能性。若必须访问、修改循环变量的值，建议重新定义一个临时变量，先将循环变量的值赋给临时变量，然后对临时变量的值进行修改

while循环语句

[init_statement]
while（test_expression）    //    后面无分号;！！！
{statement;[iteration_statement]
}

do while循环语句

[init_statement]
do
{statement;[iteration_statement]
}while（test_expression）;

for循环

for([init_statement];[test_statement];[iteration_statement])
{statement;
}
建议不要在循环体内修改循环变量的值，否则会增加程序出错的可能性。
额外定义一个变量来保存这个循环变量的值tmp = i;
选择循环变量时，习惯选择i、j、k来作为循环变量。

嵌套结构

控制循环结构

使用break结束循环

某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为false时才推出循环。此时，可以使用break来完成这个功能。break用于完全结束一个循环，跳出循环体。

break语句不仅可以结束其所在的循环，还可以直接结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标识一个外层循环。Java中的标签只有放在循环语句之前才有作用。

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

程序从外层循环进入内存循环后，当j等于1时，程序遇到一个break outer;语句，这行代码将会导致结束outer标识指定的循环，不是结束break所在的循环，而是结束break循环的外层循环。

通常紧跟break之后的标签，必须在break所在的循环的外层循环之前定义才有意义。

使用continue忽略本次循环剩下语句

continue只是忽略本次循环剩下语句，接着开始下一次循环，并不会终止循环；而break则是完全终止循环本身。

public class ContinueTest2
{public static void main(String[] args){//外层循环outer:for(int i = 0; i < 5; i++){System.out.println("i的值为：" + i + " j的值为：" + j);if(j == 1){//跳出outer标识所标识的循环中本次循环所剩下的语句continue outer;}}}
}

通常紧跟continue之后的标签，必须在continue所在的循环的外层循环之前定义才有意义。

使用return结束方法

return关键字并不是用于结束循环的，return的功能是结束一个方法。当一个方法执行到一个return语句时（return关键字后还可以跟变量、常量和表达式），这个方法将被结束。

数组类型

理解数组：数组也是一种类型

一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。

定义数组

type[] arrayName;

数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量（也就是定义了一个指针），这个引用变量还未指向任何有效的内存，因此定义数组时不能指定数组的长度。而且由于定义数组只是定义了一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有对数组进行初始化后才可以使用。

数组的初始化

所谓初始化，就是为数组的数组元素分配内存空间，并为每个数组元素赋初始值。

静态初始化

arrayName = new type[]{element1, element2, element3...};
简化的语法格式：
type[] arrayName = {element1, element2, element3...};

动态初始化

动态初始化只指定数组的长度，由系统为每个数组元素指定初始值。

arrayName = new tpye[length];
int[] prices = new int[5]    // 数组的定义和初始化同时完成，使用动态初始化语法。

默认值

整数类型    byte、short、int、long    0
浮点类型    float、double            0.0
字符类型    char                    \u0000
布尔类型    boolean                  false
引用类型    类、接口、数组            null

使用数组

数组索引是从0开始的，第一个数组元素的索引值为0，最后一个数组元素的索引值为数组长度减1。

如果访问数组元素时指定的索引值小于0，或者大于等于数组的长度，编译程序不会出现任何错误，但运行时会出现异常：java.lang.ArrayIndexOutOfBoundsException:N（数组索引越界异常），异常信息后的N就是程序员试图访问的数组索引。

所有的数组都提供了一个length属性，通过这个属性可以访问到数组的长度，一旦获得了数组的长度，就可以通过循环来遍历该数组的每个数组元素。

foreach循环

使用foreach循环遍历数组和集合元素时，无需获得数组和集合长度，无需根据索引来访问数组元素和集合元素，foreach循环自动遍历数组和集合的每个元素。

foreach循环的语法格式如下：

for(type variableName : array | collection)
{//    variableName 自动迭代访问每个元素...
}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);}}
}

使用foreach循环迭代数组元素时，并不能改变数组元素的值，因此不要对foreach的循环变量继续赋值。

深入数组

内存中的数组

实际的数组对象被存储在堆（heap）内存中；如果引用该数组对象的数组引用变量是一个局部变量，那么它被存储在栈（stack）内存中。

如果需要访问4.2所示堆内存中的数组元素，则程序中只能通过p[index]的形式实现。也就是说，数组引用变量是访问堆内存中数组元素的根本方式。

当一个方法执行时，每个方法都会建立自己的内存栈，在这个方法内定义的变量将会逐个放入这块栈内存里，随着方法的执行结束，这个方法的内存栈也将自然销毁。因此，所有在方法中定义的局部变量都是放在栈内存中的；在程序中创建一个对象时，这个对象将被保存到运行时数据区中，以便反复利用（因为对象的创建成本通常较大），这个运行时数据区就是堆内存。堆内存中的对象不会随方法的结束而销毁，即使方法结束后，这个对象还可能被另一个引用变量所引用（在方法的参数传递时很常见），则这个对象依然不会被销毁。只有当一个对象没有任何引用变量引用它时，系统的垃圾回收器才会在合适的时候回收它。

如果堆内存中数组不再有引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾回收机制回收。因此，为了让垃圾回收机制回收一个数组所占的内存空间，可以将该数组变量赋为null，也就切断了数组引用变量和实际数组之间的引用关系，实际的数组也就成了垃圾。

基本类型数组的初始化

int[] iArr;

iArr = new int[5];

for(int i = 0; i < iArr.length; i++)
{iArr[i] = i + 10;
}

引用类型数组的初始化

没有多维数组

没有多维数组——如果从数组底层的运行机制上来看。Java语言里的数值类型是引用类型，因此数组变量其实是一个引用，这个引用指向真实的数组内存。数组元素的类型也可以是引用，如果数组元素的引用再次指向真实的数组内存，这种情形看上去很像多维数组。

定义二维数组的语法： type[][] arrName; 它的实质还是一维数组，只是其数组元素也是引用，数组元素保存的引用指向一维数组。

arrName = new type[length][];

初始化多维数组时，可以只指定最左边维的大小；当然，也可以一次指定每一堆的大小。

int[][] b = new int[3][4];

Java8增强的工具类Arrays

java.util.Arrays

int binarySearch(type[] a, type key)
使用二分法查询key元素值在a数组中出现的索引；如果a数组不包含key元素值，则返回负数。调用该方法时要求数组中元素已经按升序排列，这样才能得到正确结果int binarySearch(type[] a, int fromIndex, int toIndex, type key)
只搜索fromIndex到toIndex索引的元素type[] copyOf(type[] original, int length)
将会把iriginal数组复制到一个新数组，其中length是新数组的长度。如果length小于original数组的长度，则新数组就是原数组的前面length个元素；如果length大于original数组的长度，则新数组的前面元素就是原数组的所有元素，后面补充0（数值类型）、false（布尔类型）或null（引用类型）。type[] copyOfRange(type[] original, int fromIndex, int toIndex)
只负责original数组的fromIndex索引到toIndex索引的元素boolean equals(type[] a, type[] a2)
如果a数组和a2数组的长度相等，而且a数组和a2数组的数组元素也一一相同，该方法将返回truevoid fill(type[] a, type val)
将会把a数组的所有元素赋值为valvoid fill(type[] a, int fromIndex, int toIndex， type val)
仅仅将a数组的fromIndex（包括）到toIndex索引（不包括）的数组元素赋值为valvoid sort(type[] a)
对a数组的数组元素继续排序void sort(type[] a, int fromIndex, int toIndex)
仅仅对a数组的fromIndex索引到toIndex索引的元素进行排序String toString(type[] a)
将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号(,)和空格隔开。-----------------------------
System类： static void arraycopy(Object src, int srcPos, Object dest, int desPos, int length)方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcPos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素值赋给dest数组的元素。-----------------------------
Arrays类增加了一些工具方法，这些工具方法可以充分利用多CPU并行的能力来提高设值、排序的性能。
void parallelPrefix(xxx[] array, XxxBinaryOperator op)
使用op参数指定的计算公式计算得到的结果作为新的元素。op计算公式包括left、right两个形参，其中left代表数组中前一个索引处的元素，right代表数组中当前索引处的元素，当计算第一个新数组元素时，left的值默认为1。void parallelPrefix(xxx[] array, int fromIndex, int toIndex, XxxBinaryOperator op)void setAll(xxx[] array, IntToXxxFunction generator)
使用指定的生成器generator为所有数组元素设置值，该生成器控制数组元素的值的生成算法。void parallelSetAll(xxx[] array, IntToXxxFunction generator)
功能与上一个方法相同，只是该方法增加了并行能力，可以利用多CPU并行来提高性能。void parallelSort(xxx[] a)
该方法与sort()方法相似，只是增加了并行能力，可以利用多CPU并行来提高性能。void parallelSort(xxx[] array, int fromIndex, int toIndex)Spliterator.OfXxx spliterator(xxx[] array)
将该数组的所有元素转换成对应的Spliterator对象。Spliterator.OfXxx spliterator(xxx[] array, int startInclusive, int endExclusive)
该方法仅转换startInclusive到endInclusive索引的元素。XxxStream stream(xxx[] array)
该方法将数组转换为Stream,Stream是Java8新增的流式编程的API。XxxStream stream(xxx[] array, int startInclusive, int endExclusive)   所有以parallel开头的方法都表示该方法可以利用CPU并行的能力来提高性能。上面方法中的xxx代表不同的数据类型，比如处理int[]型数组时应将xxx换成int，处理long[]型数组时应将xxx换成long。

本章练习

1.

public class NineXNine {public static void main(String[] args) {for (int i = 1; i < 10; i++) {for (int j = 1; j <= i; j++) {System.out.print(i+" x "+j+" = " + i*j);if (j != i) {System.out.print(" , ");}}System.out.println();}}
}

2.

public class Triangle {public static void main(String[] args) {Tri tri = new Tri();tri.Tri(4);}
}class Tri{public void Tri(int n) {int i;for(i = 1; i <= n; i++){for (int j1 = 1; j1 <= n-i; j1++) {System.out.print(" ");}for (int k = 1; k <= 2*i - 1; k++) {System.out.print("*");}System.out.println();}}}

3.

public class MathDraw{public static void main(String[] args){//调用绘图函数，参数是圆的半径paint(8);}public static void paint(int r){//假定圆心在坐标（r，r）处int x = 0;//x的坐标开始int y = 0;//y的坐标开始int c = 0;//中间空格数int z = 2;//每行递减量，步长设为2是为了调节屏幕纵横比。for (int i = 0; i <= r*2; i += z){//获取画*点的坐标的x值x = getX(r, y);//先画y值上左边的*System.out.print(getSpace(x)+"*");c = (r-x)*2;//以圆心对应输出空格//再画该y值上右边的*System.out.println(getSpace(c)+"*");//每次y值递减y += z;}}public static int getX(int r, int y){//取直角三角形长边长int h = y - r;//求直角三角形短边长double l = Math.sqrt((r*r)-(h*h));//取x值，Math.round()返回最接近的整数return (int) Math.round(r-l);}public static String getSpace(int i){String s = "";for(int j = 0; j < i; j++){s += " ";}return s;}}

5

import java.text.DecimalFormat;/*** Program Name: ConvertRMB <br />* Description: 将浮点金额转换成人民币读法，精确到分，例如输入：1006.33，输出：壹仟零陆元叁角叁分 <br /> 最大支持值到9999999999999998 <br />* Date: 2011-10-19 <br />* @author ChiAlvin.Chan*/public class NumToRmb {/*** @param d 需要转换的金额* @return 返回大写金额字符串（String）*/public static String convert(double d) {String[] numTables = new String[]{"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};String[] unitTables = new String[]{"分", "角"};String[] levelTables = new String[]{"万", "亿"};String[] mulTables = new String[]{"", "拾", "佰", "仟"};StringBuffer result = new StringBuffer();int index = -1;// 将数字格式化为xxxx.xxDecimalFormat df = new DecimalFormat();df.setGroupingSize(4);df.setMinimumFractionDigits(2);String strFormat = df.format(d);// 拆分整数部分和小数部分StringBuffer intPart = new StringBuffer(strFormat.substring(0, strFormat.length()-3));StringBuffer decimalPart = new StringBuffer(strFormat.substring(intPart.length()+1, strFormat.length()));// 处理小数部分decimalPart.reverse();for(int i=0; i<decimalPart.length(); i++) {result.append(unitTables[i%2]);result.append(numTables[Character.getNumericValue(decimalPart.charAt(i))]);}// 处理整数部分result.append("元");intPart.reverse();int level = 0;for(int i=0; i<intPart.length(); i++) {if(intPart.charAt(i) != ',') {result.append(mulTables[i%5]);result.append(numTables[Character.getNumericValue(intPart.charAt(i))]);} else {result.append(levelTables[level]);level = ++level % 2;}}result.reverse();// 处理多余的零while((index = result.indexOf("零分")) != -1){ result.deleteCharAt(index+1); };while((index = result.indexOf("零角")) != -1){ result.deleteCharAt(index+1); };while((index = result.indexOf("零拾")) != -1){ result.deleteCharAt(index+1); };while((index = result.indexOf("零佰")) != -1){ result.deleteCharAt(index+1); };while((index = result.indexOf("零仟")) != -1){ result.deleteCharAt(index+1); };// 没有小数部分while((index = result.indexOf("元零零")) != -1) {result.delete(index+1, index+3);result.append("整");};while((index = result.indexOf("零零")) != -1){ result.deleteCharAt(index); };while((index = result.indexOf("零元")) != -1) {result.deleteCharAt(index);};while((index = result.indexOf("零万")) != -1) {result.deleteCharAt(index);};while((index = result.indexOf("零亿")) != -1) {result.deleteCharAt(index);};while((index = result.indexOf("亿万")) != -1) {result.deleteCharAt(index+1);};// 没有分位while((index = result.indexOf("角零")) != -1){ result.deleteCharAt(index+1); };// 只有分位while((index = result.indexOf("元零")) != -1 && index == 0){ result.delete(index, index+2); };// 只有小数位while((index = result.indexOf("元")) != -1 && index == 0){ result.deleteCharAt(index); };// 零元while((index = result.indexOf("整")) != -1 && index == 0){ result.replace(index, index+2, "零元"); };return result.toString();}public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println(NumToRmb.convert(1006.33));}}