Java 流程控制与数组

摘要：静态初始化简化的语法格式动态初始化动态初始化只指定数组的长度，由系统为每个数组元素指定初始值。也就是说，数组引用变量是访问堆内存中数组元素的根本方式。

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

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语句后面的控制表达式的数据类型只能是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个部分
初始化语句、循环条件、循环体、迭代语句

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

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

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

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

某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为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只是忽略本次循环剩下语句，接着开始下一次循环，并不会终止循环；而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关键字后还可以跟变量、常量和表达式），这个方法将被结束。

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

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循环的语法格式如下：

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];

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数组的数组元素也一一相同，该方法将返回true

void fill(type[] a, type val)
将会把a数组的所有元素赋值为val

void fill(type[] a, int fromIndex, int toIndex， type val) 
仅仅将a数组的fromIndex（包括）到toIndex索引（不包括）的数组元素赋值为val

void 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 

     * Description: 将浮点金额转换成人民币读法，精确到分，例如输入：1006.33，输出：壹仟零陆元叁角叁分 
 最大支持值到9999999999999998 

     * Date: 2011-10-19 

     * @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.xx
            DecimalFormat 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