板凳-----第五章控制流

🕗 发布于 2024-07-19 21:08 java 算法 jvm

5.1 true 和 false

public class TrueFalse { 
public static void main(String[] args) { 
System.out.println( 1 == 1);
System.out.printtn(1 == 2);
}
}

5.2 if-else

public class IfElse {
  static int result = 0;
  static void test(int testval, int target) {
    if(testval > target)
      result = +1;
    else if(testval < target)           // [1]                                                                            
      result = -1;
    else
      result = 0; // Match                                                                                                
  }
  public static void main(String[] args) {
    test(10, 5);
    System.out.println(result);
    test(5, 10);
    System.out.println(result);
    test(5, 5);
    System.out.println(result);
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:IfElse
Starting a Gradle Daemon (subsequent builds will be faster)

Task :control:IfElse
1
-1
0

5.3迭代语句

public class WhileTest {
  static boolean condition() {
    boolean result = Math.random() < 0.99;
    System.out.print(result + ", ");
    return result;
  }
  public static void main(String[] args) {
    while(condition())
      System.out.println("Inside 'while'");
    System.out.println("Exited 'while'");
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:WhileTest

Task :control:WhileTest
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
true, Inside ‘while’
false, Exited ‘while’

BUILD SUCCESSFUL in 2s
4 actionable tasks: 1 executed, 3 up-to-date
condition()方法使用了 Math库里的静态方法random()。该方法会生成一个范围为0~1 (包括0,但不包括1 ) double 值。返回的结果是一个布尔值. 通过比较操作符＜产生。while条件表达式的意思是“ 复执行循环里的主体语句直到condition() 方法返回false”

5.3.1 do-while

5.3.2 for

public class ListCharacters {
  public static void main(String[] args) {
    for(char c = 0; c < 128; c++)
      if(Character.isLowerCase(c))
        System.out.println("value: " + (int)c +
          " character: " + c);
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ListCharacters

Task :control:ListCharacters
value: 97 character: a
value: 98 character: b
value: 99 character: c
value: 100 character: d
value: 101 character: e
value: 102 character: f
value: 103 character: g
value: 104 character: h
value: 105 character: i
value: 106 character: j
value: 107 character: k
value: 108 character: l
value: 109 character: m
value: 110 character: n
value: 111 character: o
value: 112 character: p
value: 113 character: q
value: 114 character: r
value: 115 character: s
value: 116 character: t
value: 117 character: u
value: 118 character: v
value: 119 character: w
value: 120 character: x
value: 121 character: y
value: 122 character: z

BUILD SUCCESSFUL in 1s
4 actionable tasks: 1 executed, 3 up-to-date

5.3.3逗号操作符

public class CommaOperator {
  public static void main(String[] args) {
    for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
      System.out.println("i = " + i + " j = " + j);
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:CommaOperator

Task :control:CommaOperator
i = 1 j = 11
i = 2 j = 4
i = 3 j = 6
i = 4 j = 8

BUILD SUCCESSFUL in 1s
4 actionable tasks: 1 executed, 3 up-to-date

5.4 for-in 语法

for-in语句会自动为你生成每一项元素这样你就不需要创建int变量来对这个元素构成的序列进行计数。

import java.util.*;

public class ForInFloat {
  public static void main(String[] args) {
    Random rand = new Random(47);
    float[] f = new float[10];
    for(int i = 0; i < 10; i++)
      f[i] = rand.nextFloat();
    for(float x : f)
      System.out.println(x);
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ForInFloat

Task :control:ForInFloat
0.72711575
0.39982635
0.5309454
0.0534122
0.16020656
0.57799757
0.18847865
0.4170137
0.51660204
0.73734957

BUILD SUCCESSFUL in 1s

任何返回了数组的方法都可以使用for-in0

public class ForInString {
  public static void main(String[] args) {
    for(char c : "An African Swallow".toCharArray())
      System.out.print(c + " ");
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ForInString
Starting a Gradle Daemon (subsequent builds will be faster)

Task :control:ForInString
A n A f r i c a n S w a l l o w

for(int i = 0；i < 100 ; i++)
你可以在import这一行看到static import语法 .对于这些语句 for-in语法不起作用因为你需要先创建一个int数组。为了简化这些任务 onJava.Range包里创建了一个range() 方法它会自动生成合适的数组。


import static onjava.Range.*;

public class ForInInt {
  public static void main(String[] args) {
    for(int i : range(10)) // 0..9
      System.out.print(i + " ");
    System.out.println();
    for(int i : range(5, 10)) // 5..9
      System.out.print(i + " ");
    System.out.println();
    for(int i : range(5, 20, 3)) // 5..20 step 3
      System.out.print(i + " ");
    System.out.println();
    for(int i : range(20, 5, -3)) // Count down
      System.out.print(i + " ");
    System.out.println();
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:ForInInt

Task :control:ForInInt
0 1 2 3 4 5 6 7 8 9
5 6 7 8 9
5 8 11 14 17
20 17 14 11 8
range()方法已经被定载(overloaded).重载表示方法名相同但具有不同的参数列表。range()方法的第一种重载形式是从0开始产生值直到范围的上限但不包括这个上限。第二种形式是从第一个参数值幵始产生值直到比第二个参数值小为止。第三种形式有一个步进值它每次增加的步幅为该值。在第四种形式中可以倒计时。range()其实就是一个简化版的生成器

5.5 return

return关键字有两种用途它可以指定一个方法的返回值(如果不存在就返回void ), 还会导致当前的方法退出并且返回这个值。

public class TestWithReturn {
  static int test(int testval, int target) {
    if(testval > target)
      return +1;
    if(testval < target)
      return -1;
    return 0; // Match
  }
  public static void main(String[] args) {
    System.out.println(test(10, 5));
    System.out.println(test(5, 10));
    System.out.println(test(5, 5));
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:TestWithReturn

Task :control:TestWithReturn
1
-1
0

如果在一个返回了 void的方法中没有return语句那么该方法的结尾处会有一个隐含的return,所以方法里并不一定会有一个return 。是如果你的方法声明了它将返回一个非void的值那就必须确保每一条代码路径都会返回一个值。

5.6 break continue

import static onjava.Range.*;

public class BreakAndContinue {
  public static void main(String[] args) {
    for(int i = 0; i < 100; i++) {        // [1]
      if(i == 74) break; // Out of for loop
      if(i % 9 != 0) continue; // Next iteration
      System.out.print(i + " ");
    }
    System.out.println();
    // Using for-in:
    for(int i : range(100)) {             // [2]
      if(i == 74) break; // Out of for loop
      if(i % 9 != 0) continue; // Next iteration
      System.out.print(i + " ");
    }
    System.out.println();
    int i = 0;
    // An "infinite loop":
    while(true) {                         // [3]
      i++;
      int j = i * 27;
      if(j == 1269) break; // Out of loop
      if(i % 10 != 0) continue; // Top of loop
      System.out.print(i + " ");
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:BreakAndContinue

Task :control:BreakAndContinue
0 9 18 27 36 45 54 63 72
0 9 18 27 36 45 54 63 72
10 20 30 40
BUILD SUCCESSFUL in 1s
通常只有在不知道中断条件何时发生时才会这样使用break。只要i不能被9整除, continue语句就会返回到循环的开头再继续执行因此这会让i值增加。如果能够整除值就被打印出来。

5.7臭名昭者的goto

goto是在源码级别上进行的跳转这给它带来了坏名声。
真正的问题并不在于goto本身而在于滥用goto.
label1:
在Java 放置标签的唯一地方是正好在迭代语句之前。“正好”的意思就是,不要在标签和迭代之间播入任何语句。在迭代之前使用标签的唯一原因是你要在这个迭代里再嵌套一个迭代或一个switch 。这是因为break continue 常只会中断当前循环但和标签一起用时它们可以中断这个嵌套的循环直接跳转到标签所在的位置。

label1: 
outer-iteration { 
inner-iteration { 
// ... 
break;     //[1]
// ... 
continue;  //[2]
// ....
continue label1; // [3]
// ...
break label1   //[4]
}
}

[1] 这里的break中断内部迭代回到外部迭代。
[2] 这里的continue中断当前执行回到内部迭代的开始位置。
[3] 这里的continue label1会同时中断内部迭代以及外部迭代直接跳到label1
然后它实际上会重新进入外部迭代开始继续执行。
[4] 这里的break label1也会中断所有迭代跳回到label1 不过它并不会重新进入外部迭代。它实际是完全跳出了两个迭代。

public class LabeledFor {
  public static void main(String[] args) {
    int i = 0;
    outer: // Can't have statements here
    for(; true ;) { // infinite loop
      inner: // Can't have statements here
      for(; i < 10; i++) {
        System.out.println("i = " + i);
        if(i == 2) {
          System.out.println("continue");
          continue;
        }
        if(i == 3) {
          System.out.println("break");
          i++; // Otherwise i never
               // gets incremented.
          break;
        }
        if(i == 7) {
          System.out.println("continue outer");
          i++; // Otherwise i never
               // gets incremented.
          continue outer;
        }
        if(i == 8) {
          System.out.println("break outer");
          break outer;
        }
        for(int k = 0; k < 5; k++) {
          if(k == 3) {
            System.out.println("continue inner");
            continue inner;
          }
        }
      }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:LabeledFor

Task :control:LabeledFor
i = 0
continue inner
i = 1
continue inner
i = 2
continue
i = 3
break
i = 4
continue inner
i = 5
continue inner
i = 6
continue inner
i = 7
continue outer
i = 8
break outer

BUILD SUCCESSFUL in 1s
注意break中断了 for循环，而 for循环在执行到末尾之前它的递增表达式不会执行。因为break导致递增表达式被跳过所以我们在i ==7的分支也是这样 continue outer语句会跳到外部循环顶部. 并且跳过内部循环的递增表达式执行因此我们在这里也进行了直接递增。如果没有break outer语句我们就没有办法从内部循环直接跳出外部循环。这是因break本身只能中断最内层的循环， continue也是一样。如果要在中断循环的同时退出方法直接用return就可以了。

普通的continue会跳到最内层循环的起始处并继续执行。
2 带标签的continue会跳到对应标签的位置并重新进入这个标签后面的循环。
3 普通的bieak “ 出循环的底部” 也就是跳出当前循环。
4 带标签的break会跳出标签所指的循环。
带标签的break continue是较少使用的试验性功能在此前的编程语言中几乎没有先例。
一定要记住 Java里使用标签的唯一理由就是你用到了嵌套循环而且你需要使break continue来跳出多层的嵌套。

5.8 switch

import java.util.*;

public class VowelsAndConsonants {
  public static void main(String[] args) {
    Random rand = new Random(47);
    for(int i = 0; i < 100; i++) {
      int c = rand.nextInt(26) + 'a';
      System.out.print((char)c + ", " + c + ": ");
      switch(c) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u': System.out.println("vowel");
                  break;
        case 'y':
        case 'w': System.out.println("Sometimes vowel");
                  break;
        default:  System.out.println("consonant");
      }
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:VowelsAndConsonants

Task :control:VowelsAndConsonants
y, 121: Sometimes vowel
n, 110: consonant
z, 122: consonant
b, 98: consonant
r, 114: consonant
n, 110: consonant
y, 121: Sometimes vowel
g, 103: consonant
c, 99: consonant
f, 102: consonant
o, 111: vowel
w, 119: Sometimes vowel
z, 122: consonant
n, 110: consonant
t, 116: consonant
c, 99: consonant
q, 113: consonant
r, 114: consonant
g, 103: consonant
s, 115: consonant
e, 101: vowel
g, 103: consonant
z, 122: consonant
m, 109: consonant
m, 109: consonant
j, 106: consonant
m, 109: consonant
r, 114: consonant
o, 111: vowel
e, 101: vowel
s, 115: consonant
u, 117: vowel
e, 101: vowel
c, 99: consonant
u, 117: vowel
o, 111: vowel
n, 110: consonant
e, 101: vowel
o, 111: vowel
e, 101: vowel
d, 100: consonant
l, 108: consonant
s, 115: consonant
m, 109: consonant
w, 119: Sometimes vowel
h, 104: consonant
l, 108: consonant
g, 103: consonant
e, 101: vowel
a, 97: vowel
h, 104: consonant
k, 107: consonant
c, 99: consonant
x, 120: consonant
r, 114: consonant
e, 101: vowel
q, 113: consonant
u, 117: vowel
c, 99: consonant
b, 98: consonant
b, 98: consonant
k, 107: consonant
i, 105: vowel
n, 110: consonant
a, 97: vowel
m, 109: consonant
e, 101: vowel
s, 115: consonant
b, 98: consonant
t, 116: consonant
w, 119: Sometimes vowel
h, 104: consonant
k, 107: consonant
j, 106: consonant
u, 117: vowel
r, 114: consonant
u, 117: vowel
k, 107: consonant
z, 122: consonant
p, 112: consonant
g, 103: consonant
w, 119: Sometimes vowel
s, 115: consonant
q, 113: consonant
p, 112: consonant
z, 122: consonant
d, 100: consonant
y, 121: Sometimes vowel
c, 99: consonant
y, 121: Sometimes vowel
r, 114: consonant
f, 102: consonant
j, 106: consonant
q, 113: consonant
a, 97: vowel
h, 104: consonant
x, 120: consonant
x, 120: consonant
h, 104: consonant
v, 118: consonant

BUILD SUCCESSFUL in 1s
Random.nextlnt(26)会产生一个0~25范围内的值所以你只需要加上一个偏移量就能生成小写字母a。 case语句中使用单引号包围的字符也能生成用于比较的整数值。
int c = rand.nextlnt(26) + ‘a’
Random.nextlnt()产生了一个0~25范围内的随机int 然后和a的值相加。这表示a会自动转换为int,以执行加法操作。

5.9字符串作为选择器

public class StringSwitch {
  public static void main(String[] args) {
    String color = "red";
    // Old way: using if-then
    if("red".equals(color)) {
      System.out.println("RED");
    } else if("green".equals(color)) {
      System.out.println("GREEN");
    } else if("blue".equals(color)) {
      System.out.println("BLUE");
    } else if("yellow".equals(color)) {
      System.out.println("YELLOW");
    } else {
      System.out.println("Unknown");
    }
    // New way: Strings in switch
    switch(color) {
      case "red":
        System.out.println("RED");
        break;
      case "green":
        System.out.println("GREEN");
        break;
      case "blue":
        System.out.println("BLUE");
        break;
      case "yellow":
        System.out.println("YELLOW");
        break;
      default:
        System.out.println("Unknown");
        break;
    }
  }
}

(base) wannian07@wannian07-PC:~/Desktop/java/example/control$ java StringSwitch
RED
RED


import onjava.*;

public class RandomBounds {
  public static void main(String[] args) {
    new TimedAbort(3);
    switch(args.length == 0 ? "" : args[0]) {
      case "lower":
        while(Math.random() != 0.0)
          ; // Keep trying
        System.out.println("Produced 0.0!");
        break;
      case "upper":
        while(Math.random() != 1.0)
          ; // Keep trying
        System.out.println("Produced 1.0!");
        break;
      default:
        System.out.println("Usage:");
        System.out.println("\tRandomBounds lower");
        System.out.println("\tRandomBounds upper");
        System.exit(1);
    }
  }
}

root@wannian07-PC:/home/wannian07/Desktop/java/example# ./gradlew control:RandomBounds

Task :control:RandomBounds
TimedAbort 3.0

原文地址：https://blog.csdn.net/fengye207161/article/details/140531832

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：制作显卡版docker并配置TensorTR环境
下一篇：LockSupport详解

leetcode289:生命游戏
根据，简称为，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。给定一个包含m × n个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态：1即为（live），或0即为
阅读更多2024-10-20
MongoDB数据恢复
注意：两个MongoDB的版本要一致，本文使用的是mongo:4.2.24。先把K8S上面的MongoDB 容器停止（可以把副本改成0）。1、将容器挂载MongoDB的数据目录备份到本地。经常是数据文
阅读更多2024-10-20
C#中实现事务
C#中实现事务
阅读更多2024-10-20
【LeetCode每日一题】——560.和为 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。
阅读更多2024-10-20
「漏洞复现」满客宝智慧食堂系统 selectUserByOrgId 未授权访问漏洞
请勿利用文章内的相关技术从事非法测试，由于传播、利用此文所提供的信息而造成的任何直接或者间接的后果及损失，均由使用者本人负责，作者不为此承担任何责任。工具来自网络，安全性自测，如有侵权请联系删除。本次
阅读更多2024-10-20
React面试题目（从基本到高级）
React前端面试常见题目涵盖了React的基础概念、组件、状态管理、生命周期、性能优化等多个方面。
阅读更多2024-10-20
12.个人博客系统（Java项目基于spring和vue）
1 在校学习的学生，可用于日常学习使用或是毕业设计使用 2 毕业一到两年的开发人员，用于锻炼自己的独立功能模块设计能力，增强代码编写能力。 3 亦可以部署为商化项目使用。 4 需要完整资料及源码
阅读更多2024-10-20
YoloV8改进策略：注意力改进|DeBiFormer，可变形双级路由注意力|引入DeBiLevelRoutingAttention注意力模块（全网首发）
本次改进的核心在于将DeBiLevelRoutingAttention模块嵌入到YoloV8的主干网络中，具体位置是在SPPF（Spatial Pyramid Pooling Fast）模块之后。这一
阅读更多2024-10-20
word取消自动单词首字母大写
情况说明：在word输入单词后首字母会自动变成大写取消单词首字母大写步骤：（1）点击菜单栏文件（2）点击“更多”——>“选项”（3）点击“校对”——>“自动更正选项”（4）取消“句首字母大
阅读更多2024-10-20
web前端网页用户注册页面
【代码】web前端网页用户注册页面。
阅读更多2024-10-20

板凳-----第五章 控制流