Skip to content

P
programiz-zh

OpenDocCN / programiz-zh
9 个月 前同步成功

通知 0
Star 48
Fork 7
P
programiz-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 b62217e6 编写于 作者: W wizardforcel
浏览文件
操作

2020-07-03 11:45:57

上级 f09bc62c
隐藏空白更改
内联 并排
Showing with 96 addition and 169 deletion
docs/java/140.md
浏览文件 @ b62217e6
......@@ -39,4 +39,4 @@ Remainder = 1
同样，要找到余数，我们使用`%`运算符。 因此，`25/4`的其余部分，即`1`存储在整数变量`其余部分`中。
最后，使用`println()`函数在屏幕上打印`商`和`余数`。
\ No newline at end of file
最后，使用`println()`函数在屏幕上打印`商`和`remainder`。
\ No newline at end of file
docs/java/150.md
浏览文件 @ b62217e6
......@@ -2,7 +2,7 @@
> 原文： [https://www.programiz.com/java-programming/examples/factorial](https://www.programiz.com/java-programming/examples/factorial)
#### 在此程序中，您将学习使用 Java 中的 for 和 while 循环查找数字的阶乘。
#### 在此程序中，您将学习使用 Java 中的`for`和`while`循环查找数字的阶乘。
正数`n`的阶乘由下式给出：
......@@ -11,7 +11,7 @@ factorial of n (n!) = 1 * 2 * 3 * 4 * ... * n
```
## 示例 1：使用 for 循环查找数字的阶乘
## 示例 1：使用`for`循环查找数字的阶乘
```java
public class Factorial {
......@@ -36,13 +36,13 @@ public class Factorial {
Factorial of 10 = 3628800
```
在此程序中，我们使用循环来循环遍历 1 至给定数字`num`（10）之间的所有数字，并将每个数字的乘积直到`num`存储在 变量`阶乘`。
在此程序中，我们使用循环来循环遍历 1 至给定数字`num`（10）之间的所有数字，并将每个数字的乘积直到`num`存储在 变量`factorial`。
我们使用了`长的`而不是`int`来存储较大的阶乘结果。 但是，它仍然不足以存储较大数字（例如 100）的值。
我们使用了`long`而不是`int`来存储较大的阶乘结果。 但是，它仍然不足以存储较大数字（例如 100）的值。
对于不能存储在长变量中的结果，我们使用在`java.math`库中声明的`BigInteger`变量。
## 示例 2：使用 BigInteger 查找数字的阶乘
## 示例 2：使用`BigInteger`查找数字的阶乘
```java
import java.math.BigInteger;
......@@ -75,9 +75,9 @@ Factorial of 30 = 265252859812191058636308480000000
* * *
同样，我们也可以使用 while 循环来解决此问题。
同样，我们也可以使用`while`循环来解决此问题。
## 示例 3：使用 while 循环查找数字的阶乘
## 示例 3：使用`while`循环查找数字的阶乘
```java
public class Factorial {
......@@ -102,8 +102,8 @@ When you run the program, the output will be:
Factorial of 5 = 120
```
在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
在上面的程序中，与`for`循环不同，我们必须在循环体内增加`i`的值。
尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（最多`num`）是已知的。
尽管两个程序在技术上都是正确的，但在这种情况下最好使用`for`循环。 这是因为迭代次数（最多`num`）是已知的。
访问此页面以学习*使用递归*查找数字的阶乘。
\ No newline at end of file
docs/java/151.md
浏览文件 @ b62217e6
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/java-programming/examples/multiplication-table](https://www.programiz.com/java-programming/examples/multiplication-table)
#### 在此程序中，您将学习生成给定数字的乘法表。 这是通过在 Java 中使用 for 和 while 循环来完成的。
#### 在此程序中，您将学习生成给定数字的乘法表。 这是通过在 Java 中使用`for`和`while`循环来完成的。
## 示例 1：使用 for 循环生成乘法表
## 示例 1：使用`for`循环生成乘法表
```java
public class MultiplicationTable {
......@@ -37,9 +37,9 @@ public class MultiplicationTable {
* * *
也可以使用 Java 中的 while 循环来生成相同的乘法表。
也可以使用 Java 中的`while`循环来生成相同的乘法表。
## 示例 2：使用 while 循环生成乘法表
## 示例 2：使用`while`循环生成乘法表
```java
public class MultiplicationTable {
......@@ -71,6 +71,6 @@ When you run the program, the output will be:
9 * 10 = 90
```
在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
在上面的程序中，与`for`循环不同，我们必须在循环体内增加`i`的值。
尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为已知迭代次数（从 1 到 10）。
\ No newline at end of file
尽管两个程序在技术上都是正确的，但在这种情况下最好使用`for`循环。 这是因为已知迭代次数（从 1 到 10）。
\ No newline at end of file
docs/java/152.md
浏览文件 @ b62217e6
......@@ -2,7 +2,7 @@
> 原文： [https://www.programiz.com/java-programming/examples/fibonacci-series](https://www.programiz.com/java-programming/examples/fibonacci-series)
#### 在该程序中，您将学习使用 for 和 while 循环在 Java 中显示斐波那契数列。 您将学习如何显示序列，直到显示一个特定的术语或数字。
#### 在该程序中，您将学习使用`for`和`while`循环在 Java 中显示斐波那契数列。 您将学习如何显示序列，直到显示一个特定的术语或数字。
斐波那契数列是一个系列，其中下一项是前两个项的总和。 斐波那契数列的前两个项是 0，然后是 1。
......@@ -11,7 +11,7 @@ The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, ...
```
## 示例 1：使用 for 循环显示斐波那契数列
## 示例 1：使用`for`循环显示斐波那契数列
```java
public class Fibonacci {
......@@ -41,13 +41,13 @@ public class Fibonacci {
在上面的程序中，第一项（`t1`）和第二项[ `t2`）分别被初始化为斐波那契数列 0 和 1 的前两个项。
然后，for 循环迭代到`n`（项数），显示存储在变量`t1`中的前两项的和。
然后，`for`循环迭代到`n`（项数），显示存储在变量`t1`中的前两项的和。
* * *
您还可以使用 Java 中的 while 循环生成 fibonacci 系列。
您还可以使用 Java 中的`while`循环生成斐波那契数列。
## 示例 2：使用 while 循环显示斐波那契数列
## 示例 2：使用`while`循环显示斐波那契数列
```java
public class Fibonacci {
......@@ -73,9 +73,9 @@ public class Fibonacci {
输出与上述程序相同。
在上面的程序中，与 for 循环不同，我们必须在循环体内增加`i`的值。
在上面的程序中，与`for`循环不同，我们必须在循环体内增加`i`的值。
尽管两个程序在技术上都是正确的，但在这种情况下最好使用 for 循环。 这是因为迭代次数（从 1 到`n`）是已知的。
尽管两个程序在技术上都是正确的，但在这种情况下最好使用`for`循环。 这是因为迭代次数（从 1 到`n`）是已知的。
* * *
......
docs/java/153.md
浏览文件 @ b62217e6
......@@ -2,11 +2,11 @@
> 原文： [https://www.programiz.com/java-programming/examples/hcf-gcd](https://www.programiz.com/java-programming/examples/hcf-gcd)
#### 在此程序中，您将学习在 Kotlin 中查找两个数字的 GCD。 这是通过在 if else 语句的帮助下使用 for 和 while 循环来完成的。
#### 在此程序中，您将学习在 Kotlin 中查找两个数字的 GCD。 这是通过在`if else`语句的帮助下使用`for`和`while`循环来完成的。
两个整数的 HCF 或 GCD 是可以完全除以两个数（没有余数）的最大整数。
## 示例 1：使用 for 循环和 if 语句查找两个数字的 GCD
## 示例 1：使用`for`循环和`if`语句查找两个数字的 GCD
```java
public class GCD {
......@@ -35,15 +35,15 @@ G.C.D of 81 and 153 is 9
这里，将要找到其 GCD 的两个数字分别存储在`n1`和`n2`中。
然后，执行 for 循环，直到`i`小于`n1`和`n2`为止。 这样，迭代 1 到两个数字中最小的所有数字以找到 GCD。
然后，执行`for`循环，直到`i`小于`n1`和`n2`为止。 这样，迭代 1 到两个数字中最小的所有数字以找到 GCD。
如果将`n1`和`n2`都除以`i`，则将`gcd`设置为该数字。 一直进行到找到最大数（GCD）为止，该数将`n1`和`n2`均除而无余数。
* * *
我们还可以使用 while 循环解决此问题，如下所示：
我们还可以使用`while`循环解决此问题，如下所示：
## 示例 2：使用 while 循环和 if else 语句查找两个数字的 GCD
## 示例 2：使用`while`循环和`if else`语句查找两个数字的 GCD
```java
public class GCD {
......
docs/java/154.md
浏览文件 @ b62217e6
......@@ -2,11 +2,11 @@
> 原文： [https://www.programiz.com/java-programming/examples/lcm](https://www.programiz.com/java-programming/examples/lcm)
#### 在此程序中，您将学习使用 GCD 而不是 GCD 查找两个数字的 lcm。 这是使用 Java 中的 for 和 while 循环完成的。
#### 在此程序中，您将学习使用 GCD 而不是 GCD 查找两个数字的 lcm。 这是使用 Java 中的`for`和`while`循环完成的。
两个整数的 LCM 是可以被两个数字完全除（没有余数）的最小正整数。
## 示例 1：使用 while 循环和 if 语句的 LCM
## 示例 1：使用`while`循环和`if`语句的 LCM
```java
public class LCM {
......@@ -41,9 +41,9 @@ The LCM of 72 and 120 is 360.
然后，我们最初将`lcm`设置为两个数字中的最大值。 这是因为 LCM 不能小于最大数量。
在无限 while 循环（`while(true)`）内，我们检查`lcm`是否完美地划分了`n1`和`n2`。
在无限`while`循环（`while(true)`）内，我们检查`lcm`是否完美地划分了`n1`和`n2`。
如果是这样，我们已经找到 LCM。 我们打印 LCM 并使用`break`语句退出 while 循环。
如果是这样，我们已经找到 LCM。 我们打印 LCM 并使用`break`语句退出`while`循环。
否则，我们将`lcm`加 1，然后重新测试除数条件。
......@@ -80,4 +80,4 @@ public class LCM {
该程序的输出与示例 1 相同。
在这里，在 for 循环内，我们计算两个数字的 GCD- `n1`和`n2`。 计算后，我们使用上面的公式来计算 LCM。
\ No newline at end of file
在这里，在`for`循环内，我们计算两个数字的 GCD - `n1`和`n2`。 计算后，我们使用上面的公式来计算 LCM。
\ No newline at end of file
docs/java/155.md
浏览文件 @ b62217e6
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/java-programming/examples/display-alphabets](https://www.programiz.com/java-programming/examples/display-alphabets)
#### 在此程序中，您将学习如何在 Java 中使用 for 循环打印英文字母。 您还将学习学会仅打印大写和小写字母。
#### 在此程序中，您将学习如何在 Java 中使用`for`循环打印英文字母。 您还将学习学会仅打印大写和小写字母。
## 示例 1：使用 for 循环显示大写的 A 到 Z
## 示例 1：使用`for`循环显示大写的 A 到 Z
```java
public class Characters {
......@@ -25,7 +25,7 @@ public class Characters {
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
```
您可以使用 for 循环在 A 到 Z 之间循环，因为它们在 Java 中存储为 ASCII 字符。
您可以使用`for`循环在 A 到 Z 之间循环，因为它们在 Java 中存储为 ASCII 字符。
因此，在内部，您可以在 65 到 90 之间循环打印英文字母。
......@@ -33,7 +33,7 @@ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
* * *
## 示例 2：使用 for 循环显示小写的 a 到 z
## 示例 2：使用`for`循环显示小写的 a 到 z
```java
public class Characters {
......@@ -54,4 +54,4 @@ When you run the program, the output will be:
a b c d e f g h i j k l m n o p q r s t u v w x y z
```
您只需将“ A”替换为“ a”，将“ Z”替换为“ z”以显示小写字母。 在这种情况下，您会在内部循环通过 97 到 122。
\ No newline at end of file
您只需将“`A`”替换为“`a`”，将“`Z`”替换为“`z`”以显示小写字母。 在这种情况下，您会在内部循环通过 97 到 122。
\ No newline at end of file
docs/java/156.md
浏览文件 @ b62217e6
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/java-programming/examples/digits-count](https://www.programiz.com/java-programming/examples/digits-count)
#### 在此程序中，您将学习在 Java 中使用 while 循环和 for 循环来计算位数。
#### 在此程序中，您将学习在 Java 中使用`while`循环和`for`循环来计算位数。
## 示例 1：使用 while 循环对整数中的位数进行计数
## 示例 1：使用`while`循环对整数中的位数进行计数
```java
public class NumberDigits {
......@@ -31,17 +31,17 @@ public class NumberDigits {
Number of digits: 4
```
在此程序中，将循环 while 循环，直到测试表达式`num != 0`的值为 0（假）。
在此程序中，将循环`while`循环，直到测试表达式`num != 0`的值为 0（假）。
* 第一次迭代后，`num`将除以 10，其值将为 345。然后，`计数`增至 1。
* 在第二次迭代后，`n` um 的值将为 34，并且`计数`递增为 2。
* 在第三次迭代后，`num`的值将为 3，并且`计数`增至 3。
* 第四次迭代后，`num`的值将为 0，并且`计数`增至 4。
* 然后将测试表达式求值为 false 并终止循环。
* 第一次迭代后，`num`将除以 10，其值将为 345。然后，`count`增至 1。
* 在第二次迭代后，`num`的值将为 34，并且`count`递增为 2。
* 在第三次迭代后，`num`的值将为 3，并且`count`增至 3。
* 第四次迭代后，`num`的值将为 0，并且`count`增至 4。
* 然后将测试表达式求值为`false`并终止循环。
* * *
## 示例 2：使用 for 循环对整数中的位数进行计数
## 示例 2：使用`for`循环对整数中的位数进行计数
```java
public class NumberDigits {
......@@ -64,13 +64,13 @@ When you run the program, the output will be:
Number of digits: 6
```
在此程序中，不使用 while 循环，而是使用不带任何主体的 for 循环。
在此程序中，不使用`while`循环，而是使用不带任何主体的`for`循环。
在每次迭代中，`num`的值除以 10，`计数`则加 1。
在每次迭代中，`num`的值除以 10，`count`则加 1。
当`num != 0`为假，即`num` = 0 时，for 循环退出。
当`num != 0`为假，即`num = 0`时，`for`循环退出。
由于 for 循环没有主体，因此可以将其更改为 Java 中的单个语句，如下所示：
由于`for`循环没有主体，因此可以将其更改为 Java 中的单个语句，如下所示：
```java
for(; num != 0; num/=10, ++count);
......
docs/java/157.md 已删除 100644 → 0
浏览文件 @ f09bc62c
# Java 程序：反转数字
> 原文： [https://www.programiz.com/java-programming/examples/reverse-number](https://www.programiz.com/java-programming/examples/reverse-number)
#### 在此程序中，您将学习在 Java 中使用 while 循环和 for 循环来反转数字。
## 示例：在 Java 中使用 while 循环反转数字
```java
public class ReverseNumber {
public static void main(String[] args) {
int num = 1234, reversed = 0;
while(num != 0) {
int digit = num % 10;
reversed = reversed * 10 + digit;
num /= 10;
}
System.out.println("Reversed Number: " + reversed);
}
}
```
运行该程序时，输出为：
```java
Reversed Number: 4321
```
在此程序中，while 循环用于按以下步骤反转数字：
* 首先，将`num`除以 10 的余数存储在变量`number`中。 现在，`number`包含`number`的最后一位，即 4。
`number`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
`num`除以 10，因此现在它仅包含前三个数字：123。
* 在第二次迭代后，`number`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`number` = 12
* 在第三次迭代后，`number`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`number` = 1
* 在第四次迭代后，`number`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`number` = 0
* 现在`num` = 0，因此测试表达式`num != 0`失败并且 while 循环退出。 颠倒的``已经包含颠倒的数字 4321。
* * *
## 示例 2：在 Java 中使用 for 循环反转数字
```java
public class ReverseNumber {
public static void main(String[] args) {
int num = 1234567, reversed = 0;
for(;num != 0; num /= 10) {
int digit = num % 10;
reversed = reversed * 10 + digit;
}
System.out.println("Reversed Number: " + reversed);
}
}
```
When you run the program, the output will be:
```java
Reversed Number: 7654321
```
在上面的程序中，while 循环被 for 循环替换，其中：
* 不使用初始化表达式
* 测试表达式保持不变（`num != 0`）
* 更新/增量表达式包含`num /= 10`。
因此，每次迭代之后，更新表达式都会运行，该表达式将删除`num`的最后一位。
当 for 循环退出时，`颠倒的`将包含颠倒的数字。
\ No newline at end of file
docs/java/158.md
浏览文件 @ b62217e6
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/java-programming/examples/power-number](https://www.programiz.com/java-programming/examples/power-number)
#### 在此程序中，您将学习使用和不使用 pow（）函数来计算数字的幂。
#### 在此程序中，您将学习使用和不使用`pow()`函数来计算数字的幂。
## 示例 1：使用 while 循环计算数字的幂
## 示例 1：使用`while`循环计算数字的幂
```java
public class Power {
......@@ -32,15 +32,15 @@ public class Power {
Answer = 81
```
在此程序中，`基`和`指数`分别分配了值 3 和 4。
在此程序中，`base`和`exponent`分别分配了值 3 和 4。
使用 while 循环，我们继续将`结果`与`基数`相乘，直到`指数`变为零。
使用`while`循环，我们继续将`result`与`base`相乘，直到`exponent`变为零。
在这种情况下，我们将`结果`乘以基数总共 4 倍，因此`结果` = 1 * 3 * 3 * 3 * 3 = 81。
在这种情况下，我们将`result`乘以基数总共 4 倍，因此`result = 1 * 3 * 3 * 3 * 3 = 81`。
* * *
## 示例 2：使用 for 循环计算数字的幂
## 示例 2：使用`for`循环计算数字的幂
```java
public class Power {
......@@ -67,15 +67,15 @@ When you run the program, the output will be:
Answer = 81
```
在这里，我们使用了 for 循环，而不是使用 while 循环。
在这里，我们使用了`for`循环，而不是使用`while`循环。
每次迭代后，`指数`减 1，然后`结果`乘以`基数` `指数`次数。
每次迭代后，`exponent`减 1，然后`result`乘以`base` `exponent`次数。
如果您的指数为负，则以上两个程序均无效。 为此，您需要在 Java 标准库中使用 pow（）函数。
如果您的指数为负，则以上两个程序均无效。 为此，您需要在 Java 标准库中使用`pow()`函数。
* * *
## 示例 3：使用 pow（）函数计算数字的幂
## 示例 3：使用`pow()`函数计算数字的幂
```java
public class Power {
......@@ -96,4 +96,4 @@ When you run the program, the output will be:
Answer = 0.012345679012345678
```
在此程序中，我们使用 Java 的`Math.pow()`函数来计算给定`基`的功率。
\ No newline at end of file
在此程序中，我们使用 Java 的`Math.pow()`函数来计算给定`base`的功率。
\ No newline at end of file
docs/java/159.md
浏览文件 @ b62217e6
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/java-programming/examples/palindrome-number](https://www.programiz.com/java-programming/examples/palindrome-number)
#### 在此程序中，您将学习如何用 Java 检查数字是否为回文。 这是通过使用 for 和 while 循环来完成的。
#### 在此程序中，您将学习如何用 Java 检查数字是否为回文。 这是通过使用`for`和`while`循环来完成的。
## 示例 1：使用 while 循环检查回文的程序
## 示例 1：使用`while`循环检查回文的程序
```java
public class Palindrome {
......@@ -40,26 +40,27 @@ public class Palindrome {
在这个程序中
* 首先，给定数字（`num`）的值存储在另一个整数变量 <samp>originalInteger</samp> 中。 这是因为，我们需要在最后比较反向编号和原始编号的值。
* 然后，使用 while 循环循环遍历 num，直到等于 0。
* 在每次迭代中，`number`的最后一位存储在`余数`中。
* 然后，将`余数`添加到`reversedInteger`，以便将其添加到下一个位置值（乘以 10）。
* 首先，给定数字（`num`）的值存储在另一个整数变量`originalInteger`中。 这是因为，我们需要在最后比较反向编号和原始编号的值。
* 然后，使用`while`循环循环遍历`num`，直到等于 0。
* 在每次迭代中，`number`的最后一位存储在`remainder`中。
* 然后，将`remainder`添加到`reversedInteger`，以便将其添加到下一个位置值（乘以 10）。
* 然后，除以 10 后，从`num`中删除最后一位数字。
* 最后，比较`reversedInteger`和`originalInteger`。 如果相等，则为回文数。 如果不是，则不是。
以下是执行的步骤：
<caption>Palindrome execution steps</caption>
| 在一个 | num！= 0 | 余 | reversedInteger |
Palindrome execution steps
| `num` | `num != 0` | `remainder` | `reversedInteger` |
| --- | --- | --- | --- |
| 121 | 真正 | 1 | 0 * 10 + 1 = 1 |
| 12 | true | 2 | 1 * 10 + 2 = 12 |
| 1 | true | 1 | 12 * 10 + 1 = 121 |
| 0 | 假 | - | 121 |
| 121 | `true` | 1 | `0 * 10 + 1 = 1` |
| 12 | `true` | 2 | `1 * 10 + 2 = 12` |
| 1 | `true` | 1 | `12 * 10 + 1 = 121` |
| 0 | `false` | - | 121 |
* * *
## 示例 2：使用 for 循环检查回文的程序
## 示例 2：使用`for`循环检查回文的程序
```java
public class Palindrome {
......@@ -92,6 +93,6 @@ When you run the program, the output will be:
11221 is not a palindrome.
```
在上面的程序中，使用 for 循环代替 while 循环。
在上面的程序中，使用`for`循环代替`while`循环。
在每次迭代中，都会执行`num /= 10`并检查条件`num !=0`。
\ No newline at end of file
docs/java/162.md
浏览文件 @ b62217e6
......@@ -51,10 +51,10 @@ public class Armstrong {
* 首先，给定数字（`number`）的值存储在另一个整数变量`originalNumber`中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
* 然后，使用 while 循环循环遍历`originalNumber`，直到等于 0。
* 在每次迭代中，`number`的最后一位存储在`余数`中。
* 然后，使用`Math.pow()`函数将`余数`加 3（数字位数），并加到`结果`上。
* 在每次迭代中，`number`的最后一位存储在`remainder`中。
* 然后，使用`Math.pow()`函数将`remainder`加 3（数字位数），并加到`result`上。
* 然后，除以 10 后，从`originalNumber`中删除最后一位数字。
* 最后，比较`结果`和`number`。 如果相等，则为阿姆斯壮数。 如果不是，则不是。
* 最后，比较`result`和`number`。 如果相等，则为阿姆斯壮数。 如果不是，则不是。
* * *
......@@ -103,6 +103,6 @@ for (;originalNumber != 0; originalNumber /= 10) {
}
```
然后，第二个 for 循环计算`结果`，其中在每次迭代中，余数由数字`n`来供电。
然后，第二个 for 循环计算`result`，其中在每次迭代中，余数由数字`n`来供电。
访问此页面了解如何[显示两个时间间隔](/java-programming/examples/armstrong-number-interval "Display all armstrong numbers between two intervals")之间的所有阿姆斯壮数字。
\ No newline at end of file
docs/java/163.md
浏览文件 @ b62217e6
......@@ -63,4 +63,4 @@ public class Armstrong {
在上述程序中，检查了给定间隔高和低之间的每个数字。
每次检查后，`位`的位数和总和`结果`被恢复为 0。
\ No newline at end of file
每次检查后，`位`的位数和总和`result`被恢复为 0。
\ No newline at end of file
docs/java/171.md
浏览文件 @ b62217e6
......@@ -38,7 +38,8 @@ G.C.D of 366 and 60 is 6.
在上面的程序中，递归函数被调用直到 n2 为 0。最后，n1 的值是给定两个数字的 GCD 或 HCF。
<caption>Execution Steps</caption>
Execution Steps
| 没有。 | 递归调用 | n1 | n2 | n1%n2 |
| --- | --- | --- | --- | --- |
| 1 | hcf（366，60） | 366 | 60 | 6 |
......
docs/java/175.md
浏览文件 @ b62217e6
......@@ -39,7 +39,8 @@ The reversed sentence is: krow oG
最后，我们以空的`句子`和`reverse()`返回相反的句子结束。
<caption>Execution steps</caption>
Execution steps
| 迭代 | 逆转（） | substring（） | reversedString |
| --- | --- | --- | --- |
| 1 | 反向（“开始工作”） | “工作” | 结果+“ G” |
......
docs/java/176.md
浏览文件 @ b62217e6
......@@ -39,7 +39,8 @@ public class Power {
3 * 3 * 3 * 3 = 81
```
<caption>Execution steps</caption>
Execution steps
| 迭代 | 功率（） | powerRaised | 结果 |
| --- | --- | --- | --- |
| 1 | 功率（3，4） | 4 | 3 *结果 <sub>2</sub> |
......
docs/java/186.md
浏览文件 @ b62217e6
......@@ -48,7 +48,8 @@ Ruby
如果 compareTo（）的返回值大于 0，则必须在位置上进行交换，即 word [i]在 word [j]之后。 因此，在每次迭代中，单词[i]包含最早的单词。
<caption>Execution Steps</caption>
Execution Steps
| 迭代 | 初始词 | 一世 | Ĵ | 话[] |
| --- | --- | --- | --- | --- |
| 1 | `{ "Ruby", "C", "Python", "Java" }` | 0 | 1 | `{ "C", "Ruby", "Python", "Java" }` |
......
docs/java/194.md
浏览文件 @ b62217e6
......@@ -39,7 +39,7 @@ public class Concat {
现在，为了将两者结合起来，我们使用 arraycopy（）函数将两个数组中的每个元素都复制为结果。
简单来说，`arraycopy(array1, 0, result, 0, aLen)`函数告诉程序将`array1`从索引`0`开始复制到`结果`从索引`0`复制到`aLen`。
简单来说，`arraycopy(array1, 0, result, 0, aLen)`函数告诉程序将`array1`从索引`0`开始复制到`result`从索引`0`复制到`aLen`。
同样，对于`arraycopy(array2, 0, result, aLen, bLen)`告诉程序从索引`0`开始将`array2`从索引`aLen`复制到`bLen`。
......@@ -81,10 +81,10 @@ When you run the program, the output will be:
[1, 2, 3, 4, 5, 6]
```
在上述程序中，我们不使用`arraycopy`，而是将两个数组`array1`和`array2`的每个元素手动复制到`结果`。
在上述程序中，我们不使用`arraycopy`，而是将两个数组`array1`和`array2`的每个元素手动复制到`result`。
我们存储`结果`所需的`总长度`，即`array1.length + array2\. length`。 然后，我们创建一个新的长度数组结果。
我们存储`result`所需的`总长度`，即`array1.length + array2\. length`。 然后，我们创建一个新的长度数组结果。
现在，我们使用 for-each 循环遍历`array1`的每个元素，并将其存储在`结果`中。 分配后，我们将位置`pos`增加 1`pos++`。
现在，我们使用 for-each 循环遍历`array1`的每个元素，并将其存储在`result`中。 分配后，我们将位置`pos`增加 1`pos++`。
同样，我们对`array2`执行相同的操作，并将每个元素从`array1`之后的位置存储在`结果`中。
\ No newline at end of file
同样，我们对`array2`执行相同的操作，并将每个元素从`array1`之后的位置存储在`result`中。
\ No newline at end of file
docs/java/24.md
浏览文件 @ b62217e6
......@@ -286,7 +286,7 @@ Squared value of 3 is: 9
Squared value of 4 is: 16
```
这里，`square(`）方法接受参数`i`并返回`i`的平方。 返回的值存储在变量`结果`中。
这里，`square(`）方法接受参数`i`并返回`i`的平方。 返回的值存储在变量`result`中。
![Example showing passing argument to method and returning value](img/a4d7ea6f6937289efc4a781e08bfa8ba.png "Passing arguments and returning a value from a method in Java")
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或