如何用不同的方法在Java中反转一个字符串？
目录
字符串是一个字符序列，在Java中表现得像一个对象。字符串是继数组之后最常见和最常用的数据结构之一。它是一个将数据存储在一个字符数组中的对象。
为了更清楚地了解情况，只需将字符串视为一个字符数组，在这里你可以解决许多基于字符串的问题。
要创建一个字符串对象，你需要java.lang.String类。Java编程使用UTF -16来表示字符串。字符串是不可变的，因此在对象完全创建后，其内部状态保持不变。字符串对象可以执行各种操作，但在Java中反向字符串是使用最广泛的功能。
Java中的反转
例子。将HELLO字符串反转并给出输出为OLLEH
如何在Java中反转一个字符串？
由于字符串是不可变的对象，你需要创建另一个字符串来反转它们。字符串类没有反转字符串的方法。它有一个toCharArray()方法来做反转。
通过使用toCharArray()
下面的代码将帮助你理解如何反转字符串。通过使用toCharArray()方法是在Java中逆转字符串的一种方法。
这段代码还使用了长度，它给出了字符串变量的总长度。
这个for循环一直迭代到字符串索引0的末端。
代码
/使用CharcterArray反转字符串。
public static void main(String[] arg) {
//声明变量
String stringinput = "Independent";
// 将字符串转换为字符数组
// 通过使用toCharArray
char[] resultarray = stringinput.toCharArray();
//迭代
for (int i = resultarray.length - 1; i >= 0; i--)
//打印反转的字符串
System.out.print(resultarray[i])。
}
输出
通过使用StringBuilder
让我们看看如何使用StringBuilder类来反转一个字符串。StringBuilder或StringBuffer类有一个内建方法reverse()来反转字符串中的字符。这个方法以相反的顺序替换字符的序列。反转方法是一个静态方法，它具有在Java中逆转字符串的逻辑。
在下面提到的代码中，使用了StringBuilder类的对象。
StringBuilder对象是可变的，内存效率高，而且执行速度快。但它也认为这些对象不是线程安全的。
该对象调用内置的reverse()方法来获得你想要的输出。
这是一个首选的方法，通常用于在Java中反转字符串。
代码。
//使用StringBuilder反转字符串。
public static void main(String[] arg) {
//声明变量
String input = "Independent"。
//创建StringBuilder对象
StringBuilder stringBuildervarible = new StringBuilder();
//将一个字符串追加到StringBuilder中 stringBuildervarible
//append是内置的方法来追加数据
stringBuildervarible.append(input)。
// reverse是StringBuilder中内置的方法，用于反转字符串
stringBuildervarible.reverse()。
//打印反转的字符串
System.out.println("反转的字符串：" +stringBuildervarible)。
}
输出。
另外，你也可以使用类似于StringBuilder的StringBuffer类的reverse()方法。无论是StringBuilder类还是StringBuffer类，都是以同样的方式在Java中逆转一个字符串。考虑到反转，两者都有相同的方法。不过，与StringBuffer类相比，StringBuilder类更受重视和青睐。StringBuilder类的速度更快，而且不同步。这些StringBuilder和StringBuffer类创建了一个可变的字符序列。为了实现理想的输出，reverse()方法将帮助你。
在Java中，由于String类是不可变的，当你处理字符串操作时，它将创建新的字符串对象。StringBuilder和StringBuffer类是java中处理字符串操作资源共享的两个实用类。
通过使用 while 循环或 For 循环
简单地在while循环或for循环中处理字符串。在光标移动的帮助下获得字符串的长度，或者通过字符串的索引进行迭代并终止循环。
循环打印出索引（i-1）所在的字符串的字符。
循环开始并迭代字符串的长度并达到索引0。
使用While循环的代码
// 使用While循环来反转字符串的Java程序
import java.lang.*;
import java.io.*;
import java.util.*;
public class strReverse {
public static void main(String[] args)
{
StringInput = "My String Output";
//获取字符串的长度
int iStrLength=stringInput.length()。
//使用While循环
while(iStrLength >0)
{
System.out.print(stringInput.charAt(iStrLength -1))。
iStrLength--。
}
}
}
输出。
使用For循环的代码
// 使用For循环逆转字符串的Java程序
import java.lang.*;
import java.io.*;
import java.util.*;
public class strReverse {
public static void main(String[] args)
{
StringInput = "My New String";
//获取字符串的长度
int iStrLength=stringInput.length()。
//使用For循环
for(iStrLength=stringInput.length();iStrLength >0;--iStrLength)
{
System.out.print(stringInput.charAt(iStrLength -1))。
}
}
}
输出。
通过将字符串转换为字节
getBytes()方法将分割或转换给定的字符串为字节。临时字节数组的长度将等于给定字符串的长度。以相反的顺序获取字节并将其存储在另一个字节数组中。
在下面的代码中，临时创建一个字节数组来处理字符串。getBytes()也是一个内置的方法，将字符串转换为字节。有两个字节数组被创建，一个用来存储转换后的字节，另一个用来存储反向顺序的结果。
代码
//使用ByteArray反转字符串。
public static void main(String[] arg) {
//声明变量
String inputvalue = "Independent";
// getBytes()是内置的方法，用于将字符串
// 转换为字节[]。
byte[] strAsByteArray = inputvalue.getBytes();
byte[] resultoutput = new byte[strAsByteArray.length]。
// 将结果按相反顺序存储到
//结果字节[]
for (int i = 0; i < strAsByteArray.length; i++)
resultoutput[i] = strAsByteArray[strAsByteArray.length - i - 1]。
System.out.println( "反转字符串：" +new String(resultoutput))。
}
输出。
通过使用ArrayList对象
使用内置方法toCharArray()，将输入的字符串转换为一个字符数组。然后，在ArrayList对象中，添加该数组的字符。Java中的集合类也有一个内置的reverse()函数。由于Collections类的reverse()方法需要一个列表对象，所以使用ArrayList对象，也就是一个字符列表，来反转这个列表。
在下面的代码中，将String内容复制到ArrayList对象中。然后，使用ArrayList对象的listIterator()方法，构造一个ListIterator对象。要对数组进行迭代，请使用ListIterator对象。这也有助于在反转的列表中进行迭代，并将每个对象逐一打印到输出屏幕上。
代码
// 使用ListIterator来反转字符串的Java程序
import java.lang.*;
import java.io.*;
import java.util.*;
// 反转字符串的类
类 ReverseString {
public static void main(String[] args)
{
String input = "Reverse a String";
char[] str = input.toCharArray();
List revString = new ArrayList<>();
for (char c : str)
revString.add(c)。
Collections.reverse(revString)。
ListIterator li = revString.listIterator();
while (li.hasNext())
System.out.print(li.next())。
}
}
输出。
通过使用StringBuffer
String类需要一个reverse()函数，因此首先使用StringBuffer方法将输入的字符串转换成一个StringBuffer。然后使用reverse()方法来反转字符串。
代码
// Java程序将String转换为StringBuffer并反转字符串
import java.lang.*;
import java.io.*;
import java.util.*;
public class strReverse {
public static void main(String[] args)
{
String str = "String";
// 从String对象转换为StringBuffer
StringBuffer sbfr = new StringBuffer(str);
// 要对字符串进行反转
sbfr.reverse()。
System.out.println(sbfr);
}
}
输出。
使用Stack
你可以使用Stack数据结构来反转一个Java字符串，使用这些步骤。
- 创建一个没有字符的堆栈。
- 通过使用String.toCharArray()方法将一个给定的字符串转换成一个字符数组，然后将每个字符推入堆栈。
- 从堆栈中取出字符，直到堆栈为空，然后将这些字符重新分配到字符数组中。这些字符将以相反的顺序进入。
- 然后通过使用String.copyValueOf(char[])将字符数组转换为字符串，然后返回形成的字符串。
代码
导入java.util.Stack.Main。 类Main { // 在Java中使用堆栈和字符数组来反转字符串的方法 public static String reverse(String str) { // 基本情况：如果字符串为空或空 如果(str == null || str.equals("")){ 返回str。 } // 创建一个空的字符栈 Stack<Character> stack = new Stack<Character>(); // 将给定字符串的每个字符推入栈中 char[] ch = str.toCharArray(); for (int i = 0; i < str.length(); i++) { stack.push(ch[i])。 } //从索引0开始 int k = 0; //从堆栈中弹出字符，直到它是空的为止 while (!stack.isEmpty()) { //将每个弹出的字符分配回字符数组中 ch[k++] = stack.pop(); } // 将字符数组转换为字符串并返回 return String.copyValueOf(ch); } public static void main(String[] args) { String str = "Techie Delight"; str = reverse(str); //字符串是不可改变的 System.out.println("给定字符串的反向是：" + str)。 } } |
输出
使用字符阵列
在Java中，字符串是不可变的，这就是为什么我们不能对字符串对象进行任何改变。然而，我们可以使用一个字符数组。
- 制作一个与字符串大小相同的字符数组。
- 用字符串中的字符向后填充这个字符数组。
- 用String.copyValueOf(char[])将字符数组转换为字符串，然后将其返回。
代码
类Main { // 在Java中使用一个字符数组来反转字符串的方法 public static String reverse(String str) { // 如果字符串为空或空，则返回 if (str == null || str.equals("")){ 返回str。 } // 获取字符串的长度 int n = str.length(); // 创建一个与字符串大小相同的字符数组 char[] temp = new char[n]; //用字符串中的字符向后填充字符数组 for (int i = 0; i < n; i++) { temp[n - i - 1] = str.charAt(i); } // 将字符数组转换为字符串并返回 return String.copyValueOf(temp); } public static void main(String[] args) { String str = "Techie Delight"; // 字符串是不可变的 str = reverse(str); System.out.println("给定字符串的反向是：" + str)。 } } |
输出
使用递归
在这里，学习如何通过使用堆栈数据结构来扭转一个Java字符串。由于涉及到堆栈，我们可以毫不费力地通过使用递归调用堆栈来转换代码。因为字符串是不可变的，我们必须首先将字符串转换为一个字符数组。一旦我们完成了这一工作，我们就将字符数组反转，并通过将字符数组再次转换为字符串来收尾。
代码
类Main
{
static int i = 0;
// 在Java中使用静态变量来反转字符串的递归方法
private static void reverse(char[] str, int k)
{
// 如果达到了字符串的末端
if (k == str.length) {
返回。
}
// 循环寻找下一个字符
reverse(str, k + 1)。
如果(i <= k)
{
char temp = str[k];
str[k] = str[i];
str[i++] = temp;
}
}
public static String reverse(String str)
{
// 基本情况：如果字符串为空或空
如果(str == null || str.equals("")){
返回str。
}
// 将字符串转换成一个字符数组
char[] A = str.toCharArray();
// 反转字符数组
reverse(A, 0);
//将字符数组转换为字符串
return String.copyValueOf(A);
}
public static void main(String[] args)
{
String str = "Techie Delight";
// 字符串是不可变的
str = reverse(str);
System.out.println("给定字符串的反向是：" + str)。
}
}
输出
使用Substring()方法
程序员可以使用String.substring(int, int)方法来递归地反转一个Java字符串。下面是一种方法。
代码
类Main { // 在Java中使用递归的方法来反转一个字符串 私有的静态字符串 reverse(String str) { // 基本情况：如果字符串为空或空 如果(str == null || str.equals("")){ 返回str。 } // 最后一个字符 + 剩余字符串的递归 返回str.charAt(str.length() - 1) + reverse(str.substring(0, str.length() - 1))。 } public static void main(String[] args) { String str = "Techie Delight"; //字符串是不可改变的 str = reverse(str); System.out.println("给定字符串的反向是：" + str)。 } } |
使用字符数组和swap()方法
这里有一个使用字符数组来反转Java字符串的有效方法。
- 首先，创建你的字符数组，并通过使用String.toCharArray()用有关字符串的字符来初始化它。
- 从两个端点 "1 "和 "h "开始，运行循环直到它们相交。在每个循环的迭代中，交换存在于索引 "l "和 "h "的值。递增 "l"，递减 "h"。
- 用String.copyValueOf(char[])将你的字符数组转换为字符串，然后返回，将事情结束。
代码
类Main
{
// 在Java中使用一个字符数组来反转字符串的方法
public static String reverse(String str)
{
// 如果字符串为空或空，则返回
if (str == null || str.equals("")){
返回str。
}
// 创建一个字符数组，并用给定的字符串初始化它
char[] c = str.toCharArray();
for (int l = 0, h = str.length() - 1; l < h; l++, h-)
{
//交换`l`和`h`的值
char temp = c[l];
c[l] = c[h];
c[h] = temp;
}
//将字符数组转换为字符串并返回
return String.copyValueOf(c);
}
public static void main(String[] args)
{
String str = "Techie Delight";
// 字符串是不可变的
str = reverse(str);
System.out.println("给定字符串的反向是：" + str)。
}
}
输出
使用Java集合框架的reverse()方法
你可以使用Collections.reverse()来逆转一个Java字符串。使用这些步骤。
- 创建一个空的字符数组，然后用String.toCharArray()初始化给定字符串的字符。
- 使用java.util.Collections reverse()方法来反转该列表。
- 最后，通过使用StringBuilder将ArrayList转换为字符串，然后返回。
代码
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
输入java.util.ListIterator。
类Main
{
// 在Java中使用`Collections.reverse()`来反转字符串的方法
public static String reverse(String str)
{
// 基本情况：如果字符串为空或空
如果(str == null || str.equals("")){
返回str。
}
// 创建一个空的字符列表
List list = new ArrayList();
//将给定字符串的每个字符推入其中
for (char c: str.toCharArray() ) {
list.add(c);
}
//使用`java.util.Collections``reverse()`来反转列表。
Collections.reverse(list);
// 使用`StringBuilder`将`ArrayList`转换成字符串并返回
StringBuilder builder = new StringBuilder(list.size())。
for (Character c: list) {
builder.append(c);
}
return builder.toString()。
}
public static void main(String[] args)
{
String str = "Techie Delight";
// 字符串是不可变的
str = reverse(str);
System.out.println("给定字符串的反向是：" + str)。
}
}
输出
总结
Java中的字符串对象是不可变的，这意味着它们是不可改变的。Java是以字符串字面的概念来处理字符串的。当一个参考变量改变了它的字符串对象的值时，它将影响所有的参考变量。
字符串类在Java中比较常用 在Java.lang.String类中，有许多方法可用于处理字符串的功能，如修剪、比较、转换等。这些方法还可以帮助你在java中反转一个字符串。
现在你已经看到了大量在java中反转字符串的不同方法。还有一些流行的第三方工具或库，如Apache Commons，可用于在java中反转字符串。
学习愉快!
