令人惊叹的 Java 代码片段：让编程变得有趣16

Java 作为一门强大的编程语言，提供了丰富的功能和可能性，让程序员能够编写高效、健壮且令人愉悦的代码。本文将展示一系列有趣的 Java 代码片段，这些片段将挑战您的思考方式，激励您的创造力，并让您领略到 Java 的趣味性。

1. 阿姆斯壮数计算

阿姆斯壮数是其各位数字的立方和等于该数本身的数。例如，153 是一个阿姆斯壮数，因为 1^3 + 5^3 + 3^3 = 153。以下 Java 代码可以计算给定整数是否为阿姆斯壮数：```java
import ;
public class ArmstrongNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner();
("Enter a number: ");
int number = ();
();
int originalNumber = number;
int sum = 0;
while (number > 0) {
int digit = number % 10;
sum += (digit, 3);
number /= 10;
}
if (sum == originalNumber) {
(originalNumber + " is an Armstrong number.");
} else {
(originalNumber + " is not an Armstrong number.");
}
}
}
```

2. 斐波那契数列生成

斐波那契数列是一个无限数列，其中每个数字都是前两个数字的和。斐波那契数列的开始几个数字是：0、1、1、2、3、5、8、13、21、34、...。以下 Java 代码可以生成给定的项数的斐波那契数列：```java
public class FibonacciSeries {
public static void main(String[] args) {
int number = 10;
int[] fib = new int[number];
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i < number; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
for (int i = 0; i < number; i++) {
(fib[i] + " ");
}
}
}
```

3. 素数检测

素数是只能被 1 和它本身整除的正整数。以下 Java 代码可以检查给定的整数是否为素数：```java
import ;
public class PrimeNumberCheck {
public static void main(String[] args) {
Scanner scanner = new Scanner();
("Enter a number: ");
int number = ();
();
boolean isPrime = true;
for (int i = 2; i 0) {
binary[index++] = number % 2;
number /= 2;
}
for (int i = index - 1; i >= 0; i--) {
(binary[i]);
}
}
}
```

5. 反转字符串

以下 Java 代码可以反转给定的字符串：```java
public class ReverseString {
public static void main(String[] args) {
String str = "Hello World";
String reversedStr = "";
for (int i = () - 1; i >= 0; i--) {
reversedStr += (i);
}
("Original string: " + str);
("Reversed string: " + reversedStr);
}
}
```

6. 快速排序

快速排序是一种高效的排序算法，通过分治法将数组划分为较小的子数组，然后递归地对子数组进行排序。以下 Java 代码实现了快速排序算法：```java
public class QuickSort {
public static void main(String[] args) {
int[] arr = {10, 7, 8, 9, 1, 5};
int n = ;
quickSort(arr, 0, n - 1);
for (int i = 0; i < n; i++) {
(arr[i] + " ");
}
}
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int partitionIndex = partition(arr, low, high);
quickSort(arr, low, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, high);
}
}
public static int partition(int[] arr, int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
}
```