顺序结构
程序从上到下逐行地执行,中间没有任何判断和跳转。
分支结构
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数组的数组元素也一一相同,该方法将返回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));
}
}
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。