Java中for循环的几种写法
Java中for循环的几种写法JDK 1.5提供了另一种形式的for循环。
借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。
本文介绍使用这种循环的具体方式，说明如何自行定义能被这样遍历的类，并解释和这一机制的一些常见问题。
在Java程序中，要“逐一处理”――或者说，“遍历”――某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现（当然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，还是因为for这个词的含义和这种操作比较配，在这种时候for循环比其它循环常用得多）。
对于遍历数组，这个循环一般是采取这样的写法：清单1：遍历数组的传统方式/* 建立一个数组*/int[] integers = {1，2，3，4};/* 开始遍历*/for (int j = 0; j< integers.length; j++){int i = integers[j];System.out.println(i);}而对于遍历Collection对象，这个循环则通常是采用这样的形式：清单2：遍历Collection对象的传统方式/* 建立一个Collection */String[] strings = {"A"，"B"，"C"，"D"};Collection stringList = java.util.Arrays.asList(strings);/* 开始遍历*/for (Iterator itr = stringList.iterator(); itr.hasNext();) {Object str = itr.next();System.out.println(str);}而在Java语言的版本――JDK 1.5后，引入了另一种形式的for循环。
借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。
1. 第二种for循环不严格的说，Java的第二种for循环基本是这样的格式：for (循环变量类型循环变量名称: 要被遍历的对象) 循环体借助这种语法，遍历一个数组的操作就可以采取这样的写法：清单3：遍历数组的简单方式/* 建立一个数组*/int[] integers = {1，2，3，4};/* 开始遍历*/for (int i : integers) {System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */}这里所用的for循环，会在编译期间被看成是这样的形式：清单4：遍历数组的简单方式的等价代码/* 建立一个数组*/int[] integers = {1，2，3，4};/* 开始遍历*/for (int 变量名甲= 0; 变量名甲System.out.println(integers[变量名甲]);/* 依次输出“1”、“2”、“3”、“4” */ }这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。
而遍历一个Collection的操作也就可以采用这样的写法：清单5：遍历Collection的简单方式/* 建立一个Collection */String[] strings = {"A"，"B"，"C"，"D"};Collection list = java.util.Arrays.asList(strings);/* 开始遍历*/for (Object str : list) {System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */}这里所用的for循环，则会在编译期间被看成是这样的形式：清单6：遍历Collection的简单方式的等价代码/* 建立一个Collection */String[] strings = {"A"，"B"，"C"，"D"};Collection stringList = java.util.Arrays.asList(strings);/* 开始遍历*/for (Iterator 变量名乙= list.iterator(); 变量名乙.hasNext();) {Object str = 变量名乙.next();System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */}这里的“变量名乙”也是一个由编译器自动生成的不会造成混乱的名字。
因为在编译期间，JDK 1.5的编译器会把这种形式的for循环，看成是对应的传统形式，所以不必担心出现性能方面的问题。
不用“foreach”和“in”的原因Java采用“for”（而不是意义更明确的“foreach”）来引导这种一般被叫做“for-each循环”的循环，并使用“:”（而不是意义更明确的“in”）来分割循环变量名称和要被遍历的对象。
这样作的主要原因，是为了避免因为引入新的关键字，造成兼容性方面的问题――在Java语言中，不允许把关键字当作变量名来使用，虽然使用“foreach”这名字的情况并不是非常多，但是“in”却是一个经常用来表示输入流的名字（例如ng.System类里，就有一个名字叫做“in”的static属性，表示“标准输入流”）。
的确可以通过巧妙的设计语法，让关键字只在特定的上下文中有特殊的含义，来允许它们也作为普通的标识符来使用。
不过这种会使语法变复杂的策略，并没有得到广泛的采用。
“for-each循环”的悠久历史“for-each循环”并不是一个最近才出现的控制结构。
在1979正式发布的Bourne shell（第一个成熟的UNIX命令解释器）里就已经包含了这种控制结构（循环用“for”和“in”来引导，循环体则用“do”和“done”来标识）。
2. 防止在循环体里修改循环变量在默认情况下，编译器是允许在第二种for循环的循环体里，对循环变量重新赋值的。
不过，因为这种做法对循环体外面的情况丝毫没有影响，又容易造成理解代码时的困难，所以一般并不推荐使用。
Java提供了一种机制，可以在编译期间就把这样的操作封杀。
具体的方法，是在循环变量类型前面加上一个“final”修饰符。
这样一来，在循环体里对循环变量进行赋值，就会导致一个编译错误。
借助这一机制，就可以有效的杜绝有意或无意的进行“在循环体里修改循环变量”的操作了。
清单7：禁止重新赋值int[] integers = {1，2，3，4};for (final int i : integers) {i = i / 2; /* 编译时出错*/}注意，这只是禁止了对循环变量进行重新赋值。
给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。
清单8：允许修改状态Random[] randoms = new Random[]{new Random(1)，new Random(2)，new Random(3)};for (final Random r : randoms) {r.setSeed(4);/* 将所有Random对象设成使用相同的种子*/System.out.println(r.nextLong());/* 种子相同，第一个结果也相同*/}3. 类型相容问题为了保证循环变量能在每次循环开始的时候，都被安全的赋值，J2SE 1.5对循环变量的类型有一定的限制。
这些限制之下，循环变量的类型可以有这样一些选择：循环变量的类型可以和要被遍历的对象中的元素的类型相同。
例如，用int型的循环变量来遍历一个int[]型的数组，用Object型的循环变量来遍历一个Collection等。
清单9：使用和要被遍历的数组中的元素相同类型的循环变量int[] integers = {1，2，3，4};for (int i : integers) {System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */}清单10：使用和要被遍历的Collection中的元素相同类型的循环变量Collection< String> strings = new ArrayList< String>();strings.add("A");strings.add("B");strings.add("C");strings.add("D");for (String str : integers) {System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */}循环变量的类型可以是要被遍历的对象中的元素的上级类型。
例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection< String>（全部元素都是String的Collection）等。
清单11：使用要被遍历的对象中的元素的上级类型的循环变量String[] strings = {"A"，"B"，"C"，"D"};Collection< String> list = java.util.Arrays.asList(strings);for (Object str : list) {System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */}循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。
JDK 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类（Wrapper Classes）之间进行转换。
因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个Collection< Byte>，也是可行的。
清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量int[] integers = {1，2，3，4};for (Integer i : integers) {System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */}注意，这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。
java中for循环的几种表示
一、基本的for循环语法在Java中，for循环是一种用于重复执行一段代码块的控制流结构。
其基本语法格式如下：```javafor (初始化; 循环条件; 迭代表达式) {// 循环体}```其中，初始化部分用于初始化循环控制变量；循环条件部分为循环条件表达式，当条件为真时执行循环体；迭代表达式用于更新循环控制变量的值。
每个部分之间由分号分隔。
二、增强for循环Java 5引入了一种新的for循环语法，即增强for循环，也称为foreach循环。
其语法格式如下：```javafor (元素类型元素变量 : 遍历对象) {// 循环体}```其中，元素类型为集合中元素的类型，元素变量为遍历过程中每个元素的变量名，遍历对象为要进行遍历的集合或数组。
增强for循环可以简化对集合或数组的遍历操作，代码更加简洁易读。
三、嵌套循环嵌套循环是指在一个循环内部再嵌套一个或多个循环的结构。
在Java 中，可以通过嵌套多个for循环来实现多维数组的遍历、组合的生成等复杂操作。
```javafor (int i = 0; i < 3; i++) {for (int j = 0; j < 3; j++) {// 循环体}}```上述代码中的嵌套for循环实现了一个3x3的二维数组的遍历操作。
通过嵌套多个循环，可以处理不同维度的数据结构，完成更为复杂的逻辑。
四、循环控制语句在for循环中，可以通过break和continue语句来控制循环的执行流程。
break语句用于跳出当前循环，终止循环的执行；continue语句用于结束本次循环迭代，继续执行下一次迭代。
```javafor (int i = 0; i < 10; i++) {if (i == 5) {continue; // 跳过本次循环}if (i == 8) {break; // 跳出循环}// 循环体}```通过使用break和continue语句，可以在特定条件下优化循环的执行流程，提高程序的效率。
javafor循环结构
javafor循环结构Java中，for循环是一种重要的循环结构，它主要用于重复执行某个任务。
for循环通常包括三个部分：初始化表达式、循环条件和更新表达式，它通过控制循环变量的取值来控制循环的次数。
具体地讲，for循环的语法如下：```for (初始化表达式; 循环条件; 更新表达式) {// 循环体代码}```其中，初始化表达式用于初始化循环变量；循环条件是一个布尔表达式，用于判断循环变量是否满足条件；更新表达式用于更新循环变量的值。
在每次循环迭代开始时，都会先执行初始化表达式，然后判断循环条件是否满足，如果满足则进入循环体执行任务，否则跳出循环。
下面是一个简单的例子，演示了如何使用for循环输出1到10之间的所有整数：```javafor (int i = 1; i <= 10; i++) {System.out.print(i + " ");}```执行结果为：1 2 3 4 5 6 7 8 9 10在实际开发中，for循环常常和其他语句结合使用，以实现更为复杂的逻辑。
例如，我们可以使用for循环遍历数组中的元素，计算数组中所有元素的和，并输出结果：```javaint[] arr = {1, 2, 3, 4, 5};int sum = 0;for (int i = 0; i < arr.length; i++) {sum += arr[i];}System.out.println("数组元素的和为：" + sum);```执行结果为：数组元素的和为：15除了简单的计数循环和数组遍历，for循环还可以嵌套，以实现更加复杂的逻辑。
例如，我们可以使用for循环嵌套输出九九乘法表：```javafor (int i = 1; i <= 9; i++) {for (int j = 1; j <= i; j++) {System.out.print(j + "×" + i + "=" + i * j + "\t");}System.out.println();}```执行结果为：1×1=11×2=22×2=41×3=32×3=63×3=91×4=42×4=83×4=124×4=161×5=52×5=103×5=154×5=205×5=251×6=62×6=123×6=184×6=245×6=306×6=36 1×7=72×7=143×7=214×7=285×7=356×7=42 7×7=491×8=82×8=163×8=244×8=325×8=406×8=487×8=568×8=641×9=92×9=183×9=274×9=365×9=456×9=54 7×9=638×9=729×9=81总之，for循环是Java编程中常用的循环结构，它可以帮助我们简化复杂的逻辑，提高代码的复用性和可读性。
Java中break、continue、return在for循环中的使用
Java中break、continue、return在for循环中的使⽤引⾔：在使⽤循环的时候，循环⾥⾯带有break、continue、return的时候经常弄混，今天特意整理了下，以待后⽤... for (int i = 1; i < 5; i++) {System.out.println(“i==for=>”+i);while(i%2==0){System.out.println(“i==while==>”+i);break;//终⽌while循环,继续for后⾯的代码;（终⽌当前(while)循环，继续循环后⾯的代码）}}打印结果：i==for=>1i==for=>2i==while==>2i==for=>3i==for=>4i==while==>4for (int i = 1; i < 5; i++) {System.out.println(“外层循环i==>”+i);for (int j = 1; j < 5; j++) {System.out.println(“内层循环j==>”+j);while(j==2){break;//终⽌while循环,继续for后⾯的代码;（终⽌当前(while)循环，继续循环后⾯的代码）}}}打印结果：外层循环i==>1内层循环j==>1内层循环j==>2内层循环j==>3内层循环j==>4外层循环i==>2内层循环j==>1内层循环j==>2内层循环j==>3内层循环j==>4外层循环i==>3内层循环j==>1内层循环j==>2内层循环j==>3内层循环j==>4外层循环i==>4内层循环j==>1内层循环j==>2内层循环j==>3内层循环j==>4for (int i = 1; i < 5; i++) {System.out.println(“外层循环i==>”+i);for (int j = 1; j < 5; j++) {System.out.println(“内层循环j==>”+j);if(j==2){System.out.println(“内层for循环结束…”);break;//终⽌当前内层for循环,继续外层for后⾯的代码;（终⽌当前循环，继续外层循环后⾯的代码）}System.out.println(“j==>”+j);}}打印结果：外层循环i==>1内层循环j==>1j==>1内层循环j==>2内层for循环结束…外层循环i==>2内层循环j==>1j==>1内层循环j==>2内层for循环结束…外层循环i==>3内层循环j==>1j==>1内层循环j==>2内层for循环结束…外层循环i==>4内层循环j==>1j==>1内层循环j==>2内层for循环结束…for (int i = 1; i < 5; i++) {while(i%2==0){System.out.println(“i==return==>”+i);return;//终⽌当前执⾏的函数,后⾯的代码不会执⾏}System.out.println(“i====>”+i);}打印结果：i====>1i==return==>2for (int i = 1; i < 5; i++) {System.out.println(“i===for=>”+i);while(i%2==0){//此循环是⼀个死循环System.out.println(“i==while==>”+i);continue;//终⽌本次while这次循环,继续while后⾯的代码;（结束本次循环，继续循环代码）}System.out.println(“i===>”+i);}打印结果：i==for=>1i===>1i==for=>2i==while==>2i==while==>2i==while==>2...从上⾯的结果来看，总的来说就是：break是跳出当前循环（最接近的循环），继续外层循环；continue则是结束本次循环，continue后⾯的代码不执⾏，继续后⾯的循环，也就是说还是在同⼀个循环内，与break有所不同，break则是跳到了外层循环；return则是终⽌当前的⽅法，该⽅法后⾯的代码都将不会执⾏。
java for语句的用法
java for语句的用法一、简介在编程语言中，循环结构是程序设计中常用的一种控制流结构。
而Java语言中的循环结构，主要通过for语句来实现。
for语句是一种遍历数组或集合、重复执行指定次数或范围的代码块的常用方式。
本文将详细介绍Java中for语句的用法及相关注意事项。
二、基本语法格式Java中for语句的基本语法格式如下：```for (初始化; 判断条件; 迭代表达式) {// 循环体代码}```其中，初始化部分用于定义和初始化循环变量；判断条件部分作为循环执行前进行判断；迭代表达式会在每次循环结束后被执行。
三、基础应用示例首先，我们看一个最简单的应用示例，以便理解for循环语句的基本用法。
```javafor (int i = 0; i < 5; i++) {System.out.println("当前值为：" + i);```上述示例会输出从0到4共5个数字，并在每行前打印"当前值为："字样。
四、循环变量与作用域在上面的示例中，我们使用了局部变量`i`作为循环变量。
需要注意的是，在for循环中定义的循环变量只在循环体内部有效，无法在循环外部直接访问。
如果需要在循环后继续使用循环变量的值，可以在循环结束后将其赋给其他变量。
五、嵌套循环Java中，我们可以通过嵌套多个for语句实现复杂的循环嵌套结构。
下面是一个示例，展示了一个2层嵌套循环打印星号图案的代码：```javafor (int i = 0; i < 5; i++) {for (int j = 0; j <= i; j++) {System.out.print("* ");}System.out.println(); // 换行}```运行上述代码将输出如下图形：```** * ** * * ** * * * *```六、break和continue语句在for循环中，我们还可以使用`break`语句和`continue`语句来控制程序执行流程。
java for循环用法
java for循环用法
java for循环是一种用来重复执行语句的语句结构。
for循环通
常用于重复执行固定次数的语句，在循环次数确定的前提下，可以节
省编程的时间和工作量，更加简洁高效。
本文将对java for循环进行
详细介绍。
java for循环的基本语法：
for(初始化语句; 条件判断; 循环后要执行的语句) {
//代码段
}
for循环共分为3个部分，初始化语句，条件判断，循环后要执
行的语句。
•初始化语句：在for循环开始之前，需要对变量进行初始化，通常是声明变量并赋值，用于在循环过程中保存循环次数。
•条件判断：在循环内部，会不断的判断某个变量的值，当
变量的值满足条件，就继续循环，否则跳出循环。
•循环后要执行的语句：在每一次循环结束后，都会执行的
语句，通常是改变变量的值，以便开始下一轮循环。
for循环的好处在于，不管循环次数是多少，都可以通过相同的
方式来实现，大大节省了编程的工作量，对于简单重复性操作很有用。
此外，java中还有另一种for循环——foreach循环，此循环用
于遍历集合中的元素，当拥有一个元素的集合时，可以使用foreach
循环来遍历元素，节省更多的时间和工作量。
总之，java for循环是一种非常实用的语句结构，能够减少编程的工作量，简化程序流程，是不可或缺的编程技术。
java for循环方法
java for循环方法Java中的for循环是一种非常常用的控制结构，可以用来重复执行一段代码块。
它的语法形式为：for (初始化; 条件; 更新) { 代码块}。
在这篇文章中，我们将深入探讨Java中的for循环，并介绍一些常见的用法和技巧。
让我们来看一下for循环的语法。
初始化部分用于初始化循环变量，条件部分用于判断是否继续循环，更新部分用于更新循环变量的值。
在每次循环开始之前，都会执行一次初始化部分。
在每次循环结束之后，都会执行一次更新部分。
如果条件部分的值为true，循环将继续执行，否则循环将结束。
for循环的用法非常灵活，可以根据具体的需求进行调整。
例如，可以使用for循环来遍历数组或集合中的元素。
在循环的每一次迭代中，可以通过循环变量来访问数组或集合中的元素，并对其进行操作。
这样可以方便地处理大量的数据。
除了遍历数组或集合，for循环还可以用于实现数值的累加或累乘。
在每次循环中，可以通过更新部分来改变循环变量的值，从而实现累加或累乘的效果。
这在一些数学计算或统计分析的场景中非常有用。
for循环还可以用于实现嵌套循环。
嵌套循环是指在一个循环体内部再嵌套一个或多个循环体的情况。
通过嵌套循环，可以实现更复杂的控制逻辑。
例如，可以使用嵌套循环来输出九九乘法表或打印一些特殊的图形。
除了以上常见的用法，for循环还可以结合条件语句来实现更灵活的控制流程。
例如，可以使用break语句来提前终止循环，或者使用continue语句来跳过当前迭代，进入下一次迭代。
在使用for循环时，我们还需要注意一些常见的问题。
首先是循环变量的作用域。
循环变量只在循环体内部有效，如果在循环体外部使用循环变量，将会导致编译错误。
其次是循环条件的判断。
循环条件的判断结果应该是一个布尔值，如果判断结果为其他类型，将会导致编译错误。
最后是循环变量的更新。
循环变量的更新部分应该能够使循环条件的判断结果发生改变，否则将导致死循环。
java中for循环写法
java中for循环写法在Java中，for循环是一种常用的循环结构，用于重复执行一段代码，可以按照指定的条件和步长进行迭代。
下面我将从不同的角度介绍Java中for循环的写法。
1. 基本写法：for (初始化语句; 循环条件; 循环迭代) {。
// 循环体代码。
}。
初始化语句在循环开始前执行一次，循环条件用于判断是否继续循环，循环迭代用于每次循环结束后执行，循环体代码是需要重复执行的代码块。
2. 初始化语句：初始化语句用于初始化循环控制变量，可以是声明和赋值语句，也可以是多个语句用逗号分隔。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
3. 循环条件：循环条件是一个布尔表达式，用于判断是否继续执行循环。
当循环条件为true时，继续执行循环；当循环条件为false时，跳出循环。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
4. 循环迭代：循环迭代用于每次循环结束后对循环控制变量进行操作，可以是递增或递减操作，也可以是其他复杂的操作。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
5. 循环体代码：循环体代码是需要重复执行的代码块，可以是单条语句或多条语句的组合。
循环体代码执行完毕后，再次判断循环条件，如果满足条件则继续执行循环，否则跳出循环。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
6. 嵌套循环：在循环体中可以再次使用循环结构，形成嵌套循环，用于处理更复杂的问题。
for (int i = 0; i < 10; i++) {。
for (int j = 0; j < 5; j++) {。
// 循环体代码。
}。
}。
以上是关于Java中for循环的基本写法和相关要点的介绍。
通过灵活运用for循环，可以实现各种不同的循环需求。
java for 写法 -回复
java for 写法-回复关于"java for 写法"的主题，我将逐步回答并为您撰写一篇1500-2000字的文章。
【引言】在Java编程语言中，有许多循环结构可供使用。
其中之一是for循环，被广泛应用于迭代操作和循环控制。
本文将详细介绍Java中for循环的写法和使用技巧，以帮助读者更好地理解和应用。
【正文】一、基本语法在Java中，for循环通常由三个主要组成部分构成：初始化、条件判断和迭代，如下所示：for (初始化; 条件判断; 迭代) {循环体代码}其中，初始化部分用于声明并定义循环变量，通常用于初始化计数器。
条件判断部分用于判断循环是否继续执行，当条件不满足时，循环会终止。
迭代部分用于更新循环变量的值，以便下一次循环的执行。
二、循环变量循环变量是指在for循环中被初始化和迭代的变量。
通常用于控制循环的执行次数。
可以使用任意有效的Java数据类型作为循环变量，如int、double、char、boolean等，甚至可以使用对象类型。
例如，使用循环变量控制循环执行10次：for (int i = 0; i < 10; i++) {循环体代码}在上述示例中，循环变量i被初始化为0，在每次循环迭代时递增1，直到循环终止条件不满足为止。
三、循环控制语句在for循环中，可以使用多种循环控制语句来改变循环的执行流程，如break语句和continue语句。
1. break语句：用于立即终止当前循环，并跳出该循环，继续执行循环后的代码。
for (int i = 0; i < 10; i++) {if (i == 5) {break; 当循环变量i等于5时，跳出循环}循环体代码}在上述示例中，当循环变量i等于5时，程序立即跳出循环，不再执行循环体内的代码。
2. continue语句：用于跳过当前循环的剩余代码，直接进行下一次循环迭代。
for (int i = 0; i < 10; i++) {if (i 2 == 0) {continue; 当循环变量i为偶数时，跳过本次循环}循环体代码}在上述示例中，当循环变量i为偶数时，程序将直接跳过循环体内的代码，进行下一次循环迭代。
Java for循环讲解
Java for循环讲解for循环基本语法语法格式：for(①初始化部分;②循环条件部分;④迭代部分)｛③循环体部分;｝执行过程：①-②-③-④-②-③-④-②-③-④-.....-②图示：说明：•①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔•②循环条件部分为boolean类型表达式，当值为false时，退出循环•④可以有多个变量更新，用逗号分隔•for(;;)中的两个；不能多也不能少应用举例案例1：格式的多样性题目：写出输出的结果public class ForTest2 {public static void main(String[] args){int num =1;for(System.out.print("a");num <3;System.out.print("c"),num++){ System.out.print("b");}}}案例2：使用for循环重复执行某些语句题目：输出5行HelloWorldpublic class ForTest1 {public static void main(String[] args){//需求1：控制台输出5行Hello World!//写法1：//System.out.println("Hello World!");//System.out.println("Hello World!");//System.out.println("Hello World!");//System.out.println("Hello World!");//System.out.println("Hello World!");//写法2：for(int i =1;i <=5;i++){System.out.println("Hello World!");}}}案例3：累加的思想题目：遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和public class ForTest3 {public static void main(String[] args){int count =0;//记录偶数的个数int sum =0;//记录偶数的和for(int i =1;i <=100;i++){if(i %2==0){System.out.println(i);count++;sum += i;}//System.out.println("偶数的个数为：" + count);}System.out.println("偶数的个数为："+ count);System.out.println("偶数的总和为："+ sum);}}案例4：结合分支结构使用题目：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
java for循环的三种写法
在Java中，有三种常见的方式可以使用`for`循环。
下面是这三种写法的示例：1. 基本`for`循环：```javafor (初始化; 条件; 更新) {// 循环体代码}```示例：```javafor (int i = 0; i < 5; i++) {System.out.println("当前值为: " + i);}```2. 增强`for`循环（也称为`foreach`循环）：```javafor (元素类型元素变量 : 遍历对象) {// 循环体代码}```示例：```javaint[] nums = {1, 2, 3, 4, 5};for (int num : nums) {System.out.println("当前值为: " + num);}```3. `for-each`循环（用于遍历集合类对象）：```javafor (元素类型元素变量 : 集合对象) {// 循环体代码}```示例：```javaList<String> names = Arrays.asList("Alice", "Bob", "Charlie");for (String name : names) {System.out.println("当前名字为: " + name);}```这三种写法都可以实现循环控制，并根据不同的需求选择合适的方式。
基本`for`循环提供了更大的灵活性，适用于需要手动管理循环变量和更新条件的情况。
增强`for`循环和`for-each`循环则更加简洁，适用于遍历数组或集合对象的场景。