在 Java 中反轉字串的不同方法

java中的字串也可以說是字元數組。java中的字串用於儲存文字/字元。在java程式語言中，字串被視為物件。在Java中，字串是一個預先定義的對象，該類別名為String。所有的字串變數都是java中String類別的實例。因此我們可以理解，java中的字串並不像其他程式語言中的int或char那樣是原始型別。在本文中，我們將閱讀如何在java中反轉字串，前提是你應該知道如何在java 中建立字串，內建字串方法的基本概念，以及如何借助循環執行操作。

文章的範圍

- 在本文中，我們將了解如何在 java 中反轉字串的各種方法。- 我們還將看到一些預先建立的方法，透過它們我們可以反轉 java 中的字串。- 我們還將了解 java 中每個反向方法的時間和空間複雜度。- Java 中有多種反轉字串的方法，每種方法都有其優點和缺點。在本文中，我們將探討一些在 Java 中反轉字串的最常用方法。

介紹

字串是java中不可變的對象，字串只是java中的字元序列。java中的單行字串是用單引號定義的，而java中的多行字串是用三引號定義的，java有幾種可用的字串方法，但今天在本文中我們將了解如何在java中反轉字串的不同方法。Java程式語言是世界上使用最廣泛的程式語言之一，以其簡單易用而聞名。程式設計師對字串執行的最常見操作之一是反轉它們。在本文中，我們將討論在 Java 中反轉字串的不同方法。首先，讓我們來了解一下在 java 中使用 for 迴圈的最常見方法：

java中使用for迴圈反轉字串：

該技術是 Java 中使用 for 迴圈反轉字串的最簡單方法之一。我們可以從末尾到開頭迭代字串的字符，並將它們添加到新的字串變數中。以下是如何使用for 迴圈 反轉字串的範例：

//in the above code we have reversed the string using a for loop in java  
public class reverseofthestring {
  public static void main(String[] args) {
    
    String s1 = "java is fun";
      // we are creating the second string to store the reversed string and print it while iterating the for loop
    String s2 = "";
    
    for(int i = s1.length()-1; i>=0; i--)
    {
        // in the above line we have stored the reversed string by iterating the for loop from the last index and stored the value in the second string created s2. 
      s2 = s2 + s1.charAt(i);
    }
    
    System.out.print("The reversed string of the '"+s1+"' is: " );
    System.out.println(s2);
  }
}

輸出

The reversed string of the s1 is:nuf si avaj

在上面的程式碼中，我們首先輸入名為 s1 的字串並建立一個空字串 s2，然後從最後一個索引開始迭代 for 循環，然後儲存該字串中每個字元的值。在編輯器中運行上述程式碼以獲得更好、更清晰的解釋。上面程式碼的時間複雜度是 O(N)，而且由於我們迭代了所有 n 個元素，所以上面程式碼的空間複雜度是 O(N)。現在讓我們了解下一個過程，即使用字串生成器反轉字串，現在讓我們詳細了解它：

使用字串建構器類別反轉字串

我們也可以使用 StringBuilder 類別來反轉 Java 中的字串。StringBuilder 類別提供了一個reverse() 方法，可用來反轉字串。Java StringBuilder 類別的reverse() 方法用於將該字元序列替換為該序列的逆序。java中的StringBuilder類別 沒有toCharArray()方法，String類別有toCharArray()方法。現在讓我們透過一個例子來理解：

public class reverseusingbuilder {  
    public static void main(String[] args) {  
        StringBuilder s1 = new StringBuilder("abc");  
        System.out.println("The original string1 is  = " + s1);  
        StringBuilder s2 = new StringBuilder("cab");  
        System.out.println("The original string2 is = " + s2);  
         StringBuilder s3 = new StringBuilder("wer");  
        System. out.println("The original string3 is = " + s3);  
        // reversing of stringbuilder  
        System.out.println("The reverse of the string is reverse1 = " + s1.reverse());  
        System.out.println("The reverse of the string2 is reverse2 = " + s2.reverse());  
         System.out.println("The reverse of the string3 is reverse2 = " + s3.reverse());  
    }  
}  

輸出

The original string1 is  = abc
The original string2 is  =cab
The original string3 is  =wer
The reversed string1 is  = cba
The reversed string2 is  = bac
The reversed string3 is  =rew

在這個方法中，我們可以看到使用內建的字串建構器類別我們已經反轉了字串。此方法非常有效，因為它只需要一次通過字串。但是，它確實需要建立一個新的 StringBuilder 對象，這會增加一些開銷。此方法相對簡單且易於理解，但其效率可能低於其他方法，因為它需要多次遍歷字串並為每個字元建立新字串。在編輯器中運行上述程式碼以獲得更好、更清晰的解釋。現在讓我們看看另一種使用遞歸技術反轉字串的方法：

使用遞歸反轉字串

遞歸是一種函數呼叫自身的技術。我們可以使用遞歸將字串分解為更小的子字串來反轉字串。java中的遞歸是一個方法不斷地呼叫自身的過程。要使用遞歸在java中反轉字串，首先我們必須從字串中刪除第一個字符，然後將該字符附加到字串的末尾，然後我們必須重複上述步驟，直到輸入字串變空。現在讓我們透過一個例子來理解這一點：

public class reverse string   
{  
//in this line we are writing the recursive function to reverse a string      
public String reverse string(String s1)  
{  
//first we will check if the string is empty or not  
if(s1.isEmpty())  
{  
System. out.println("String is empty.")  
//if the above condition is true then it returns the same string as if the string is empty itself then we cannot reverse the string     
return s1;  
}   
else   
{  
return reverseString(s1.substring(1))+s1.charAt(0);  
}  
}  
public static void main(String[] args)   
{  
reversestring q1 = new reversestring();  
String res1 = q1.reverseString("JAVA IS FUN");  
String res2 = q1.reverseString("STRINGS OBJECTS JAVA");  
String res3 = q1.reverseString("IMMUTABLE CLASS OBJECTS");  
System.out.println(res1);  
System.out.println(res2);  
System.out.println(res3);   
}  
}

輸出

NUF SI AVAJ
AVAJ STCEJBO SGNIRTS
STCEJBO SSALC ELBATUMMI

因此我們可以看到，在上面使用遞歸我們已經反轉了字串，我們首先檢查字串是否為空，如果字串為空，那麼就沒有可以反轉的字元。此方法比 for 迴圈方法更有效，因為它只需要一次遍歷字串。然而，它也可能更複雜、更難理解，因為它涉及遞歸 的使用。在編輯器中運行上述程式碼以獲得更好、更清晰的解釋。讓我們來看另一個如何在 java 中使用遞歸反轉字串的範例：

public static String reverseusingrecursion(String s1) {
    if (s1.length() == 1) {
        return s1;
    }
    //We have applied recursion in this line 
    return s1.charAt(s1.length() - 1) + reverseUsingRecursion(s1.substring(0, s1.length() - 1));
}

現在讓我們了解另一種在 java 中使用陣列反轉字串的方法：

java中使用陣列反轉字串

我們還可以透過將字串轉換為字元數組，更改數組，然後將其轉換回字串來反轉字串。首先，我們必須創建一個與給定字串大小相同的空字元數組，然後我們必須用給定字串的字元向後填充字元數組，最後我們必須使用以下命令將字元數組轉換為字串複製方法並返回它。現在讓我們透過一個例子來理解這一點：

public class Main
{
    // In this Method of conversion we have to reverse a string in Java using a character array
    public static String reverse(String s1)
    {
        // we have to check if the string is empty or not and return if the string is null or empty
        if (s1 == null || s1.equals("")) {
            return s1;
        }
 // if it is equal to empty then we will simply print the string and break it.
        // else we will find the string length
        int len = str.length();
 
        // and then we have to create a character array of the same size as that of the string to store the value after reversing
        char[] new_arr = new char[n];
 
        // and by iterating the loop backward we have to fill the character array backward with characters in the string
        for (int i = 0; i < len; i++) {
            new_arr[len - i - 1] = str.charAt(i);
        }
 
        // and in the final step after reversing we have to convert the character array to string and return it
        to return String.copy value of(new_arr);
    }
 
    public static void main(String[] args)
    {
        // taking a string input for reverse
        String s1 = "JAVA IS FUN";
 
        // In this line we are calling the reverse function and reversing the string
        str = reverse(str);
 
        System.out.println("The reversed string is " + s1);
    }
}

輸出

NUF SI AVA

在這個方法中，我們必須將字串反轉為我們知道的字元數組，因此首先我們將檢查字串是否為空，如果字串為空則返回，如果等於空則返回空，然後我們將簡單地列印字串並否則我們會找到字串的長度，然後我們必須建立一個與字串大小相同的字元陣列來儲存反轉後的值，並且透過向後迭代循環，我們必須用字串中的字元向後填充字元數組在反轉後的最後一步中，我們必須將字元數組轉換為字串並返回它。在編輯器中運行上述程式碼以獲得更好、更清晰的解釋。現在讓我們了解下一步，我們也可以使用 Stream API 在 java 中反轉字串。現在讓我們藉助一些範例來詳細了解它們：

使用 Stream API 在 java 中反轉字串：

Java 8 引進了 Stream API，可用於對集合執行函數式操作。我們可以使用 Stream API 來反轉字串，方法是將其轉換為字元流，反轉流，然後將其轉換回字串。我們可以使用各種流和收集器在java中反轉字串，首先我們必須輸入一個字串，然後使用整個String上的Map到StringBuilder物件中，同時使用StringBuilder類別的reverse()方法反轉它，最後，使用Stream 收集反轉後的字串。collect() 方法和收集器。join() 方法我們將列印原始/反轉字串及其長度。現在讓我們透過一個例子來理解這一點：

public static String reverseUsingStream(String str) {
    return str. chars()
              .mapToObj(c -> (char) c)
              .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
              .reverse()
              .toString();
}

在此範例中，我們使用 java 流和收集器反轉了 java 中的字串。在編輯器中運行上述程式碼以獲得更好、更清晰的解釋。現在讓我們看看如何使用堆疊反轉字串。現在讓我們藉助範例詳細了解它：

使用堆疊反轉字串

Java 中還有另一種反轉字串的方法，就是使用堆疊。其思想是將輸入字串的每個字元壓入堆疊，然後從堆疊中彈出字元以獲得反轉的字串。現在讓我們藉助一個範例來詳細了解它：

public static String reverse string(String input) {
    Stack<character> stack = new Stack<>();
    for (int i = 0; i < input.length(); i++) {
        stack.push(input.charAt(i));
    }
    StringBuilder sb = new StringBuilder();
    while (!stack.isEmpty()) {
        sb.append(stack.pop());
    }
    return sb.toString();
}

</character>

在上面的範例中，我們首先建立了一個空堆疊，然後反轉字串並將元素插入到堆疊中。此方法簡單、易懂、有效率。在編輯器中運行上述程式碼以獲得更好、更清晰的解釋。

結論

第一種方法是使用 StringBuilder 類，該類別具有內建的reverse() 方法，該方法傳回與原始字串相反的新字串。第二種方法是使用 for 循環，將原始字串轉換為 char 數組，並以相反的順序迭代該數組，將相應的字元分配給新的 char 數組，最後使用該 char 數組建立新字串。第三種方法是使用遞歸，我們呼叫遞歸函數，透過將字串的第一個字元與其餘字元的反轉子字串連接來解決問題。第四種方法是在java中使用陣列來反轉字串。在第五種方法中，我們使用流API和java收集器來反轉字串，在最後一個方法中，我們使用堆疊來反轉java中的字串。這些方法都有其優點和缺點，方法的選擇取決於問題的特定要求和程式設計師的偏好。總的來說，這些方法展示了 Java 在字串操作方面的靈活性和多功能性。