Java 中一些棘手的程序

7 Jan 2025 | 7 分钟阅读

Java 是一种通用的编程语言，拥有一套丰富的特性，可以满足各种编程需求。从简单的应用程序到复杂的系统，Java 提供了许多工具和技术来处理各种编程挑战。其中一些是展示 Java 功能的有趣程序，有时也突出了语言不太明显的特性。这些程序不仅提供了实践见解，还为加深对核心 Java 概念的理解提供了机会。

1. 不使用临时变量交换

交换值是编程中的基本操作，Java 提供了多种方法来完成此操作。一种特别有趣的方法是不使用临时变量来交换两个变量。这可以通过算术运算或按位异或运算来实现。

使用算术运算

算术运算提供了一种简单的方法来交换值，而无需为临时变量分配额外的内存。但是，如果值太大而导致溢出，此方法可能会有问题。

文件名：SwapWithoutTemp.java

 
public class SwapWithoutTemp {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        System.out.println("Before Swap: a = " + a + ", b = " + b);
        // Swap using arithmetic operations
        a = a + b; // a becomes 15
        b = a - b; // b becomes 5 (15 - 10)
        a = a - b; // a becomes 10 (15 - 5)
        System.out.println("After Swap: a = " + a + ", b = " + b);
    }
}   

输出

 
Before Swap: a = 5, b = 10
After Swap: a = 10, b = 5

解释

加法：a 更新为 a 和 b 的总和。

减法：通过从新的 a 中减去 b，b 被更新为原始的 a 值。

再次减法：通过从新的 b 中减去新的 b，a 被更新为原始的 b 值。

使用按位异或

按位异或运算提供了一种巧妙的替代方法，可以避免与算术运算相关的溢出问题。

 
public class SwapWithoutTemp {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        System.out.println("Before Swap: a = " + a + ", b = " + b);
        // Swap using bitwise XOR
        a = a ^ b; // a becomes 15 (binary 1111)
        b = a ^ b; // b becomes 5 (binary 0101)
        a = a ^ b; // a becomes 10 (binary 1010)
        System.out.println("After Swap: a = " + a + ", b = " + b);
    }
}   

输出

 
Before Swap: a = 5, b = 10
After Swap: a = 10, b = 5

解释

异或运算：a 被更新为 a 和 b 的异或。

更新 b：b 被更新为新的 a 和 b 的异或，结果为原始的 a。

更新 a：a 被更新为新的 a 和更新后的 b 的异或，结果为原始的 b。

2. 不使用额外空间检查回文

回文是指从前往后读和从后往前读都相同的字符串。可以使用两个指针从字符串的两端进行比较，从而有效地在不使用额外空间的情况下检查字符串是否为回文。

文件名：PalindromeCheck.java

 
public class PalindromeCheck {
    public static void main(String[] args) {
        String str = "racecar";
        boolean isPalindrome = true;
        int left = 0;
        int right = str.length() - 1;
        while (left < right) {
            if (str.charAt(left) != str.charAt(right)) {
                isPalindrome = false;
                break;
            }
            left++;
            right--;
        }
        System.out.println("Is '" + str + "' a palindrome? " + isPalindrome);
    }
}   

输出

 
Is 'racecar' a palindrome? true

3. 带备忘录的递归斐波那契

斐波那契数列是一个常见的算法问题，可以使用备忘录进行优化。该技术存储中间结果以避免重复计算。

文件名：Fibonacci.java

 
import java.util.HashMap;
import java.util.Map;
public class Fibonacci {
    private static Map<Integer, Integer> memo = new HashMap<>();
    public static int fib(int n) {
        if (n <= 1) return n;
        if (memo.containsKey(n)) return memo.get(n);
        int result = fib(n - 1) + fib(n - 2);
        memo.put(n, result);
        return result;
    }
    public static void main(String[] args) {
        int n = 10;
        System.out.println("Fibonacci of " + n + " is " + fib(n));
    }
}   

输出

 
Fibonacci of 10 is 55

解释

备忘录映射：使用 HashMap 存储先前计算的斐波那契数。

递归函数：fib 方法递归计算斐波那契数，并从映射中查找缓存的结果。

优化：该方法通过存储中间结果来避免重复计算，从而提高了性能。

4. 处理浮点精度问题

由于数字在内存中的表示方式，浮点精度可能导致意外的结果。该程序演示了精度问题如何显现以及如何处理它们。

文件名：PrecisionExample.java

 
public class PrecisionExample {
    public static void main(String[] args) {
        double a = 0.1 + 0.2;
        double b = 0.3;
        System.out.println("a == b: " + (a == b)); // Might be false
        // Using tolerance for comparison
        final double EPSILON = 1e-10;
        System.out.println("Math.abs(a - b) < EPSILON: " + (Math.abs(a - b) < EPSILON)); // Should be true
    }
}   

输出

 
a == b: false
Math.abs(a - b) < EPSILON: true

解释

精度问题：由于精度错误，直接比较浮点数 (a == b) 可能会失败。

容差比较：通过检查 a 和 b 之间的差值是否在很小的容差（EPSILON）范围内，我们可以可靠地比较浮点数。

5. 注释执行程序

我们仍然了解到注释在 Java 中不被执行。现在我们将学习如何在 Java 中执行注释。

文件名：CommentExecution.java

 
public class CommentExecution { 
    public static void main(String[] args) 
     { 
         // the following statement executes and gives an output 
         // \u000d System.out.println("javatpoint"); 
     } 
}    

输出

 
javatpoint

在上面的 Java 程序中，我们看到 Java 编译器将 unicode 字符 **\u000d** 解析为新行，并转换为以下内容。

 
public class CommentExecution { 
    public static void main(String[] args) 
    { 
        // \u000d 
        System.out.println("javatpoint"); 
    } 
}    

6. 命名或带标签的循环程序

**名称**或**标签**是有效的变量名，表示应跳转到执行控制的循环的名称。要为循环设置标签，请将标签放在循环之前，并在末尾加上冒号。因此，带有标签的循环称为**带标签的循环**。

通俗地说，我们可以说标签只不过是为循环提供一个名称。在使用嵌套循环时，为循环设置标签是一个好习惯。我们也可以将标签与 **continue** 和 **break** 语句一起使用。Java 中有三种循环

for 循环
while 循环

让我们使用标签讨论以上三种循环。

Java 带标签的 for 循环

标记 for 循环在我们需要根据要求 break 或 continue 特定 for 循环时非常有用。如果我们将在内部 for 循环中放置一个 break 语句，编译器将跳出内部循环并再次继续外部循环。

如果我们想使用内部循环中的 break 语句跳出外部循环该怎么办？答案是，我们应该在循环之前定义标签以及冒号（:）符号。

语法

 
labelname:    
for(initialization; condition; incr/decr)  
{    
//functionality of the loop    
}       

让我们看一个带标签的 for 循环的例子。

文件名：NamedLoop.java

 
public class NamedLoop
{ 
    public static void main(String[] args) 
    { 
    loop1: //name of for loop
    for (int i = 0; i < 3; i++) 
     { 
        for (int j = 0; j < 3; j++)  
        { 
            if (i == 3) 
                break loop1; 
            System.out.println("i = " + i + " j = " + j); 
        } 
    } 
   } 
}    

输出

 
i = 0 j = 0
i = 0 j = 1
i = 0 j = 2
i = 1 j = 0
i = 1 j = 1
i = 1 j = 2
i = 2 j = 0
i = 2 j = 1
i = 2 j = 2

Java 带标签的 while 循环

语法

 
labelName:   
while ( ... )    
{  
//statements to execute  
}     

文件名：LabledWhileLoop.java

 
public class LabledWhileLoop  
{  
public static void main(String args[])   
{  
int i = 0;  
whilelabel:   
while (i < 5)   
{  
System.out.println("outer value of i= " + i);  
i++;  
forlabel:   
for (int j = 0; j < 5; j++)   
{  
if (j > 0)   
{  
//execution transfer to the for loop      
continue forlabel;  
}  //end of if  
if (i > 1)   
{  
//execution transfer to the while loop      
continue whilelabel;  
}  //end of if  
System.out.println("inner value of i= " + i + ", j= " + j);  
}  //end of for  
}  //end of while  
}  //end of main  
}     

输出

 
outer value of i= 0
inner value of i= 1, j= 0
outer value of i= 1
outer value of i= 2
outer value of i= 3
outer value of i= 4

结论

这些棘手的 Java 程序阐述了该语言的各种高级和细微的方面，演示了如何以创造性和有效的方式处理常见的编程挑战。

理解这些棘手的程序可以提供对 Java 的特性和功能的宝贵见解，从而增强实际编程技能和理论知识。每个示例都有助于更广泛地理解如何解决复杂问题以及有效地利用 Java 的广泛功能集。

下一个主题Find-largest-rectangle-in-matrix-java

Java 中一些棘手的程序

1. 不使用临时变量交换

使用算术运算

解释

使用按位异或

解释

2. 不使用额外空间检查回文

3. 带备忘录的递归斐波那契

解释

4. 处理浮点精度问题

解释

5. 注释执行程序

6. 命名或带标签的循环程序

Java 带标签的 for 循环

Java 带标签的 while 循环

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中一些棘手的程序

1. 不使用临时变量交换

使用算术运算

解释

使用按位异或

解释

2. 不使用额外空间检查回文

3. 带备忘录的递归斐波那契

解释

4. 处理浮点精度问题

解释

5. 注释执行程序

6. 命名或带标签的循环程序

Java 带标签的 for 循环

Java 带标签的 while 循环

结论

相关帖子

How to Run Java Program in Eclipse

Program to Accept String Starting With Capital Letter in Java

Java 中的组合设计模式

Time Class Operation in Java

Java 中的 Repaint() 方法

Merge Sort in Java

Java ByteBuffer 大小

Java 中模拟 N 个骰子滚动器的程序

Java 中的局部变量

Java 都有哪些“术语”？

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器