我想在Java中反转字符串并删除和复制

将字符串转换为字节：getBytes（）方法用于将输入字符串转换为字节[]。 方法：

创建长度等于的临时字节[] 设置为输入字符串的长度

存储字节（我们使用 getBytes（）方法）按相反顺序转换为 临时字节[]

使用字节[]创建一个新的字符串abject 存储结果

来源

// Java program to ReverseString using ByteArray. 
import java.lang.*; 
import java.io.*; 
import java.util.*; 

// Class of ReverseString 
class ReverseString 
{ 
    public static void main(String[] args) 
    { 
        String input = "Geeks"; 

        // getBytes() method to convert string  
        // into bytes[]. 
        byte [] strAsByteArray = input.getBytes(); 

        byte [] result =  
                   new byte [strAsByteArray.length]; 

        // Store result in reverse order into the 
        // result byte[] 
        for (int i = 0; i<strAsByteArray.length; i++) 
            result[i] =  
             strAsByteArray[strAsByteArray.length-i-1]; 

        System.out.println(new String(result)); 
    } 
} 

//使用ByteArray反转字符串的Java程序。
导入java.lang.*；
导入java.io.*；
导入java.util.*；
//反向限制类
类反向限制
{ 
公共静态void main（字符串[]args）
{ 
字符串输入=“极客”；
//用于转换字符串的getBytes（）方法
//转换为字节[]。
字节[]strAsByteArray=input.getBytes（）；
字节[]结果=
新字节[strAsByteArray.length]；
//将结果按相反顺序存储到
//结果字节[]
对于（int i=0；i您需要跟踪当前字节，如果与前一个字节相同，则不添加以下字节：

String input = "Geeks";
byte[] strAsByteArray = input.getBytes(); 
List<Byte> list = new ArrayList<>();
//byte[] result = new byte[strAsByteArray.length];
byte prev = 0;

for (int i=0; i < strAsByteArray.length; i++) {
    byte curr = strAsByteArray[strAsByteArray.length-i-1];
    if (curr != prev) {
        prev = curr;
        list.add(curr);
    }
}

byte[] result = new byte[list.size()];
for (int i=0; i < list.size(); ++i) {
    result[i] = list.get(i);
}

System.out.println(new String(result));

请注意，我最初使用列表来存储字节，因为在反向解析整个字符串之前，我们实际上不知道固定字节数组的最终大小。我想找到一种巧妙的方法，使用流将
列表
转换为基元字节数组。如果失败，我只使用了增强的for loop、 
您需要跟踪当前字节，如果与上一个字节相同，则不要添加以下字节：

String input = "Geeks";
byte[] strAsByteArray = input.getBytes(); 
List<Byte> list = new ArrayList<>();
//byte[] result = new byte[strAsByteArray.length];
byte prev = 0;

for (int i=0; i < strAsByteArray.length; i++) {
    byte curr = strAsByteArray[strAsByteArray.length-i-1];
    if (curr != prev) {
        prev = curr;
        list.add(curr);
    }
}

byte[] result = new byte[list.size()];
for (int i=0; i < list.size(); ++i) {
    result[i] = list.get(i);
}

System.out.println(new String(result));

请注意，我最初使用列表来存储字节，因为在反向解析整个字符串之前，我们实际上不知道固定字节数组的最终大小。我想找到一种巧妙的方法，使用流将
列表
转换为基元字节数组。如果失败，我只使用了增强的for loop、 
您只需使用以下语法将
字节[]
转换为字符串：

System.out.println(new String(result, "UTF-8");

您只需使用以下语法将
字节[]
转换为字符串：

System.out.println(new String(result, "UTF-8");

执行嵌套循环。
这不需要使用集合/列表。
在创建结果后放置此项

byte[] finalResult = new byte[result.length];
int k = 0;

for (int i = 0; i < result.length; i++) {
    boolean hasDuplicates = false;

    for (int j = i + 1; j < result.length; j++) {
        if (result[i] == result[j]) {
            hasDuplicates = true;
        }
    }

    if (!hasDuplicates) {
           finalResult[k++] = result[i];
    }
}

System.out.println(new String(finalResult));

byte[]finalResult=新字节[result.length]；
int k=0；
for（int i=0；i

示例：欢迎

结果：moclew

不确定这是否是您的预期响应


有一种更好的方法，只使用较少的循环。
执行嵌套循环。
这不需要使用集合/列表。
在创建结果后放置此项

byte[] finalResult = new byte[result.length];
int k = 0;

for (int i = 0; i < result.length; i++) {
    boolean hasDuplicates = false;

    for (int j = i + 1; j < result.length; j++) {
        if (result[i] == result[j]) {
            hasDuplicates = true;
        }
    }

    if (!hasDuplicates) {
           finalResult[k++] = result[i];
    }
}

System.out.println(new String(finalResult));

byte[]finalResult=新字节[result.length]；
int k=0；
for（int i=0；i

示例：欢迎

结果：moclew

不确定这是否是您的预期响应


有一种更好的方法，只使用更少的循环。
这就是我一直在寻找的解决方案

    public class CodeExercise

{

publicstaticvoidmain（字符串[]args）
{
字符串输入=“abbac”；
char[]strArr=input.toCharArray（）；
字符串结果=”；
//逆转
对于（int i=strArr.length-1；i>=0；i--）{
结果=结果+strArr[i]；
}
结果=移除的副本（result.toCharArray（））；
System.out.println（新字符串（结果））；
}
//折叠任何相邻的重复字符
移除重复的公共静态字符串（char[]chars）
{
char prev='\0'；
int x=0；
for（int i=0；i

}这就是我一直在寻找的解决方案

    public class CodeExercise

{

publicstaticvoidmain（字符串[]args）
{
字符串输入=“abbac”；
char[]strArr=input.toCharArray（）；
字符串结果=”；
//逆转
对于（int i=strArr.length-1；i>=0；i--）{
结果=结果+strArr[i]；
}
结果=移除的副本（result.toCharArray（））；
System.out.println（新字符串（结果））；
}
//折叠任何相邻的重复字符
移除重复的公共静态字符串（char[]chars）
{
char prev='\0'；
int x=0；
for（int i=0；i

}
你在哪里检查副本？你在哪里检查副本？如果副本不连续怎么办？@Kartik我在原始问题中没有看到/解释这一要求。如果我遗漏了什么，我会等待OP的评论。如果副本不连续怎么办？@Kartik我没有看到/解释这一要求如果我遗漏了什么，我会等待OP的评论。