标签：
|
流程控制与数组
顺序结构
•顺序结构就是程序从上到下一行一行地执行，中间没有任何判断和跳转。 •如果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后代码块的花括号
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];
个数。 使用数组
•数组最常用的用法就是访问数组元素，包括对数组元素赋值和访问数组元素的值，访问数组元素是通过在数组引用变 量后紧跟一个方括号（[ ]），方括号里是数组元素的索引值。
•Java语言的数组索引是从0开始的，也就是说，第一个数组元素的索引值为0，最后一个数组元素的索引为数组长度 减1。
•如果访问数组元素进指定的索引小于0，或者大于等于数组的长度，编译程序不会出现任何错误，但运行时出现异 常：java.lang.ArrayIndexOutOfBoundsException:2（数组索引越界异常），在这个异常提示信息后有一个int 整数，这个整数就是程序员试图访问的数组索引。
•所有数组都提供了一个length属性，通过这个属性可以访问到数组的长度，一旦获得了数组的长度后，就可以通过循 环来遍历该数组的每个数组元素。 JDK1.5 提供了foreach循环
•从JDK1.5 之后，Java提供了一种更简单的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用 foreach循环遍历数组和集合元素时，无须获得数组和集合长度，无须根据索引来访问数组元素和集合元素， foreach循环自动遍历数组和集合的每个元素。
•当使用foreach循环来迭代输出数组元素或集合时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允 许的，但没有太大的意义，而且极容易引起错误。 深入数组
•数组元素和数组变量在内存里是分开存放的。
中。
•如果堆内存中数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾 回收机制回收。因此，为了让垃圾回收机制回收一个数组所占的内存空间，则可以将该数组变量赋为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]); } } }
引用类型数组的初始化
引用类型数组的数组元素是引用，因此情况变得更加复杂：每个数组元素里存储的还是引用，它指向另一块内存， 这块内存里存储了有效数据。 没有多维数组
•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 } 我们可以得到一个结论：
二维数组是一维数组，其数组元素是一维数组；三维数组也是一维数组，其数组元素是二维数组；四维数组还是一维数 组，其数组元素是三维数组……从这个角度来看，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("青年人"); } } // 中年人 }
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("青年人"); } } // 中年人 }
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("老年人"); } } // 青年人 }
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("老年人"); } } // 青年人 }
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 }
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("季节输入错误"); } } // 夏日炎炎. }
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("成绩输入错误"); } } // 中 }
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++; } } }
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 // 循环结束! }
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("循环结束!"); } }
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 // 循环结束! }
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 // 循环结束! }
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 }
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 }
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++; } } }
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 }
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 }
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后的输出语句 }
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 }
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 }
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 }
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企业应用实战 }
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讲义 }
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 }
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] }
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)); } }
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的格式："); } } // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ // ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋ }
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] // 陆百零玖 }
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] // 陆百零玖 }
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; } } }
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(); } }
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 }
|
标签：
原文地址：http://www.cnblogs.com/pipi-changing/p/5399985.html
