在 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 在字符串操作方面的灵活性和多功能性。