java中的几种for循环形式,java for循环的特点

发布时间：2022-11-20

本文目录一览：

  1. java的for循环一共有几种写法
  2. 三种for循环：就这三种
  3. java中有什么循环吗？
  4. [Java for循环几种写法整理](#Java for循环几种写法整理)
  5. java中for循环的几种写法
  6. 什么是循环?Java中有哪些循环？

java的for循环一共有几种写法

for(初始化;条件;条件成立后执行){} 下面两个是语法糖：

  • for(一个完成iterable接口的实例:取出的元素名){}
  • for(一个数组类:取出的元素名){} 或者，对于for(初始化;条件;条件成立后执行){}你可以把三个都写出去： 如：
int a=0; 
for(;true;){ 
    a=a+1;
    if(a10){
        break;
    }
}

三种for循环：就这三种

注1：在少量数据情况下，这三种性能区别不大 注2：需要循环数组结构的数据时，建议使用普通for循环，因为for循环采用下标访问，对于数组结构的数据来说，采用下标访问比较好。需要循环链表结构的数据时，一定不要使用普通for循环，这种做法很糟糕，数据量大的时候有可能会导致系统崩溃

详解：

注3： 测试性能的文章： 一.普通for循环 二.增强for循环：return/break/continue 都有效的 注：数组也可以用 增强for循环原理： ;seid=1245652931602669854spm_id_from=333.337.0.0 3.遍历List、Set、Map 示例： 三. lambda foreach循环：List、Set、Map都有，stream也可以使用 注：数组没有这个方法 1.使用return/break/continue 都无效 return起的作用和continue 一样 ;utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-5.no_search_linkdepth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-5.no_search_link ;utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-5.no_search_linkdepth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-5.no_search_link 评论区有说

java中有什么循环吗？

JAVA语言编程中常用的三种循环流程图

  1. for循环 for循环形式： for（表达式1；表达式2；表达式3） 流程图： 图1 for循环流程图
  2. while循环 while循环形式：
while（判断条件）{
    执行语句；
}

流程图： 图2 while循环流程图 3. do-while循环 do-while循环形式：

do{
    执行语句；
}while（条件判断）

do-while循环流程图： 图3 do-while循环流程图

Java for循环几种写法整理

  1. 遍历数组的传统方式
/* 建立一个数组 */
int[] integers = {1, 2, 3, 4};
/* 开始遍历 */
for (int j = 0; j < integers.length; j++){
    int i = integers[j];
    System.out.println(i);
}
  1. 遍历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);
}
  1. 遍历数组的简单方式
/* 建立一个数组 */
int[] integers = {1, 2, 3, 4};
/* 开始遍历 */
for (int i : integers) {
    System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
}
  1. 遍历数组的简单方式的等价代码
/* 建立一个数组 */
int[] integers = {1, 2, 3, 4};
/* 开始遍历 */
for (int 变量名甲 = 0; 变量名甲 < integers.length; 变量名甲++) {
    System.out.println(integers[变量名甲]);/* 依次输出“1”、“2”、“3”、“4” */
}
  1. 遍历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” */
}
  1. 遍历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” */
}
  1. 禁止重新赋值
int[] integers = {1, 2, 3, 4};
for (final int i : integers) {
    i = i / 2; /* 编译时出错 */
}
  1. 允许修改状态
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());/* 种子相同，第一个结果也相同 */
}
  1. 使用和要被遍历的数组中的元素相同类型的循环变量
int[] integers = {1, 2, 3, 4};
for (int i : integers) {
    System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
}
  1. 使用和要被遍历的Collection中的元素相同类型的循环变量
Collection<String> strings = new ArrayList<>();
strings.add("A");
strings.add("B");
strings.add("C");
strings.add("D");
for (String str : strings) {
    System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
}
  1. 使用要被遍历的对象中的元素的上级类型的循环变量
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” */
}
  1. 使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量
int[] integers = {1, 2, 3, 4};
for (Integer i : integers) {
    System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
}

java中for循环的几种写法

以下为for循环的几种写法：

方法一：最普通的不加思考的写法

  • 优点：较常见，易于理解
  • 缺点：每次都要计算list.size()
for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

方法二：数组长度提取出来

  • 优点：不必每次都计算
  • 缺点：
    1. m的作用域不够小，违反了最小作用域原则
    2. 不能在for循环中操作list的大小，比如除去或新加一个元素
int m = list.size();
for (int i = 0; i < m; i++) {
    System.out.println(list.get(i));
}

方法三：数组长度提取出来

  • 优点：
    1. 不必每次都计算
    2. 所有变量的作用域都遵循了最小范围原则
  • 缺点：
    1. m的作用域不够小，违反了最小作用域原则
    2. 不能在for循环中操作list的大小，比如除去或新加一个元素
for (int i = 0, n = list.size(); i < n; i++) {
    System.out.println(list.get(i));
}

方法四：采用倒序的写法

  • 优点：
    1. 不必每次都计算
    2. 所有变量的作用域都遵循了最小范围原则
  • 缺点：
    1. 结果的顺序会反
    2. 看起来不习惯，不易读懂
  • 适用场合：与显示结果顺序无关的地方：比如保存之前数据的校验
for (int i = list.size() - 1; i >= 0; i--) {
    System.out.println(list.get(i));
}

方法五：Iterator遍历

  • 优点：简洁
  • 缺点：
for (Iterator<String> it = list.iterator(); it.hasNext();) {
    System.out.println(it.next());
}

方法六：jdk1.5新写法

  • 优点：简洁结合泛型使用更简洁
  • 缺点：jdk1.4向下不兼容
for (Object o : list) {
    System.out.println(o);
}

什么是循环?Java中有哪些循环？

循环就是反复的执行同一件事情； 比如：求1到100的累加和就是反复执行 sum = sum + i ; i = i + 1; java循环有三种：

  1. do while 循环
  2. while 循环
  3. for 循环

1. do while 循环 至少执行一次

语法格式：

do {
    至少执行一次循环体
    sum = sum + i ;//累加自然整数i到sum
    i = i + 1;//自然整数加一到下一个整数
} while(i <= 100);

2. while 循环

语法格式：

while(i <= 100){
    //可能一次都不执行
    sum = sum + i ;//累加自然整数i到sum
    i = i + 1;//自然整数加一到下一个整数
}

3. for 循环

语法格式：

for(int i=1; i <= 100; i++){
    //可能一次都不执行
    sum = sum + i ;//累加自然整数i到sum
    i = i + 1;//自然整数加一到下一个整数
}

你明白了吗？

推荐文章