顺序结构

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

分支结构

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来作为循环变量。

嵌套结构

clipboard.png

控制循环结构

使用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)内存中。

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

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

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

基本类型数组的初始化

int[] iArr;

clipboard.png

iArr = new int[5];

clipboard.png

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

clipboard.png

引用类型数组的初始化

没有多维数组

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

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

arrName = new type[length][];

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

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

clipboard.png

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数组的数组元素也一一相同,该方法将返回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 <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.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<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 stub
            System.out.println(NumToRmb.convert(1006.33));
        }

    }

布still
461 声望32 粉丝

数据挖掘、用户行为研究、用户画像