Java 将大写字母移动到字符串的末尾

Ques：给定一个字符串作为输入，将所有大写字母移到字符串的末尾。例如：

move("Hello World")="ello orldHW"

问题是：我的代码并没有在

ello-orldHW

处停止，但它仍在继续

ello orldHW // Expected output   
ello orldWH // What I am actually getting

代码：

公共类MoveUppercaseChars{
静态字符串testcase1=“Hello World”；
公共静态void main（字符串参数[]）{
MoveUppercaseChars testInstance=新的MoveUppercaseChars（）；
字符串结果=testInstance.move（testcase1）；
System.out.println（“结果：+Result”）；
}
公共字符串移动（字符串str）{
int len=str.length（）；
char ch；
对于（int i=0；i=65）&（（int）ch分别存储小写字符和大写字符，然后返回两者的串联：

public class MoveUppercaseChars {   

static String testcase1 = "Hello World";

public static void main(String args[]){
    MoveUppercaseChars testInstance = new MoveUppercaseChars();
    String result = testInstance.move(testcase1);
    System.out.println("Result : "+result);
}

public String move(String str){
    int len = str.length();
    String low = "";
    String cap = "";
    char ch;
    for(int i=0; i<len; i++)
    {
        ch = str.charAt(i);
        if(((int)ch >= 65) && ((int)ch <= 90))
        {
            cap  += ch;
        }   
        else {
            low += ch;
        }
    }
    return low + cap;
}   
}

公共类MoveUppercaseChars{
静态字符串testcase1=“Hello World”；
公共静态void main（字符串参数[]）{
MoveUppercaseChars testInstance=新的MoveUppercaseChars（）；
字符串结果=testInstance.move（testcase1）；
System.out.println（“结果：+Result”）；
}
公共字符串移动（字符串str）{
int len=str.length（）；
字符串低=”；
字符串cap=“”；
char ch；
对于（int i=0；i=65）和（（int）ch而言，问题在于单词
H
被处理了两次，在第二次处理过程中被推到了末尾

您可能希望跟踪已处理的大写单词总数，以便它们不再被处理

此外，还可以使用
检查字符是否为大写

public class Test {

    public static void main(String[] args){
        System.out.println(move("Hello World"));
    }

    public static int getUpperCaseLetters(String str) {
        int r = 0;
        for(char c : str.toCharArray()) {
            if(Character.isUpperCase(c)) {
                r++;
            }
        }
        return r;
    }

    public static String move(String str){
        int len = str.length();
        char ch;
        int totalUppercase = getUpperCaseLetters(str);
        int processed = 0;
        for(int i=0; i<len && processed < totalUppercase; i++)
        {
            ch = str.charAt(i);
            if(Character.isUpperCase(ch))
            {
                str = str.substring(0, i) + str.substring(i+1, len) + str.charAt(i);                
                System.out.println(str);
                processed++;
            }           
        }
        return str;
    }   
}

公共类测试{
公共静态void main（字符串[]args）{
System.out.println（move（“helloworld”）；
}
公共静态整型getUpperCaseLetters（字符串str）{
int r=0；
for（字符c:str.toCharArray（））{
if（字符.大写（c））{
r++；
}
}
返回r；
}
公共静态字符串移动（字符串str）{
int len=str.length（）；
char ch；
int totalUppercase=getUpperCaseLetters（str）；
int=0；
对于（inti=0；i我会使用辅助字符串缓冲区以正确的顺序存储大写字母，甚至小写字母，因此创建的字符串实例更少

public String move(String str){
    char ch;
    int len = str.length();
    // we initialize the buffers with the size so they won't have to be increased
    StringBuffer sbUpperCase = new StringBuffer(len+1);
    StringBuffer sbLowerCase = new StringBuffer(len+1);

    for(int i=0; i<len; i++)
    {
        ch = str.charAt(i);

        //if it is an upperCase letter (but only of the normal ones
        if(Character.isUpperCase(ch))
        {
            sbUpperCase.append(ch);
        }   else {
            sbLowerCase.append(ch);
        }        
    }
    return sbLowerCase.append(sbUpperCase).toString();
} 

公共字符串移动（字符串str）{
char ch；
int len=str.length（）；
//我们用大小初始化缓冲区，这样它们就不必增加
StringBuffer sbUpperCase=新的StringBuffer（len+1）；
StringBuffer sbLowerCase=新的StringBuffer（len+1）；
对于（int i=0；i将循环更改为从字符串末尾开始，然后向后工作。此外，使用char[]数组，比在循环的每次迭代中构建新字符串更快。类似于：

编辑：这可能是最有效的方法：

    char[] input = str.toCharArray();
    int c = input.length; // cursor to start at
    int ip = input.length - 1; // insertion point of next UP character.
    while (c > 0) {
        c--;
        if (Character.isUpperCase(input[c])) {
            char tmp = input[c];
            System.arraycopy(input, c + 1, input, c, ip - c);
            input[ip] = tmp;
            ip--;
        }
    }
    return new String(input);

编辑：下面的循环不是最有效的……因此将此代码示例向下移动

boolean gotUC=true; // do we have upper-case letters, initialize to true
char[] input = str.toCharArray();
int len = input.length;
while (len > 1 && gotUC) {
    len--;
    int c = len;
    while (c > 0 && !Character.isUpperCase(input[c])) {
       c--;
    }
    if (c >= 0) {
        // move the UC Char to before previous UCase letters....
        char tmp = input[c];
        System.arraycopy(input, c + 1, input, c, len - c);
        input[len] = tmp;
    } else {
        gotUC = false;
    }
}
return new String(input);

最简单和最小的代码解决方案：

public String move(String str) {
    return s.replaceAll("[A-Z]+", "") + s.replaceAll("[^A-Z]+", "");
}

基于非正则表达式的解决方案：

使用此算法可以变得非常简单：

public String move(String str){
    StringBuilder sb = new StringBuilder(str);
    int d=0;
    for(int i=0; i<str.length(); i++) {
        int ch = str.charAt(i);
        if(ch >= 65 && ch <= 90) {
            sb.deleteCharAt(i-d++).append((char)ch);
        }           
    }
    return sb.toString();
}  

公共字符串移动（字符串str）{
StringBuilder sb=新的StringBuilder（str）；
int d=0；
对于（int i=0；i=65&&ch
公共字符串移动（字符串str）{
int todo=str.length（）；
int i=0；
而（我如果（c>=65&&c我将在输入字符串上循环两次，首先复制小写字母，然后复制大写字母

public static String move(String str) {
    char[] input = str.toCharArray();
    char[] result = new char[input.length];
    int index = 0;

    for (char current : input)
        if (!Character.isUpperCase(current))
            result[index++] = current;

    for (char current : input)
        if (Character.isUpperCase(current))
            result[index++] = current;

    return new String(result);
}

public类将大写字母移动到end{
公共静态void main（字符串[]args）{
String=“软件工程师”；
字符串结果=大写（字符串）；
系统输出打印项次（结果）；
}
公共静态字符串大写（字符串s）{
字符串小写=”；
字符串大写=”；
对于（int i=0；i如果（ch>='A'&&ch），我不理解您的预期输出和实际输出之间的区别。您想说它打印了两次吗？WH被重新设置，并且似乎打印了两次。忘记这个语句System.out.println（str）；取“我的名字是詹姆斯·邦德”作为输入。预期输出：y名称是ames ondMJB实际输出：y名称是ames ondJMB我希望您现在能理解我的问题。输入“我住在新德里”输出应该是“住在新德里”，但它给出了“住在新德里”。我希望你现在明白问题是什么了。@abhishek14d我一开始还没有弄明白。我更正了我的代码。试试看。是的，就是这样。谢谢！嘿！我先回答了这个问题，使用了字符串缓冲区，效率更高！太不公平了…@Daren抱歉，但我没有看你的代码来复制，我在eclipse上开发了我自己的代码。他们不是真的同样，对于初学者来说，我的更干净，尽管你的可能更聪明，甚至更高效，但我不确定。这将跳过第二个大写字母，以获得任何连续的大写字母（原始代码也是如此）。与原始代码类似，这将跳过任何一对大写字符中的第二个。除非我以某种方式看错了，否则我认为这不起作用。您正在检查
str.charAt（I）
，但随后删除
I-d
。可能
int ch=str.charAt（I-d）
？@JamesMontagne:
d
（已删除计数器）从0开始，每次删除它都会递增以从缓冲区中偏移已删除的字符。请参阅此工作演示：我的错误，您正在查看
str
中的字符，因此
sb
的操作不会影响那里的索引。我收回这一点+1@abhishek14d我刚刚想到了另一个非常小的解决方案：
s。replaceAll（“[A-Z]+”，“）+s.replaceAll（“[^A-Z]+”，”）；
您的评论对我来说毫无意义……如果您担心字符.isUpperCase（），那么只需将其更改为您的测试：input[c]>='A'&&input[c]
public String move(String str) {
    int todo = str.length();
    int i = 0;
    while (i < todo)
    {
        char c = str.charAt(i);
        if (c >= 65 && c <= 90) {
            str = str.substring(0, i) + str.substring(i + 1, str.length())
                    + str.charAt(i);
            --todo;
            --i;
        }
        ++i;
    }
    return str;
}

public static String move(String str) {
    char[] input = str.toCharArray();
    char[] result = new char[input.length];
    int index = 0;

    for (char current : input)
        if (!Character.isUpperCase(current))
            result[index++] = current;

    for (char current : input)
        if (Character.isUpperCase(current))
            result[index++] = current;

    return new String(result);
}

public class MoveUpperCaseToEnd {

public static void main(String[] args) {
    String string = "SoftwareEngineer";
    String result = moveUpperCase(string);
    System.out.println(result);

}

public static String moveUpperCase(String s) {
    String lowerCase = "";
    String upperCase = "";
    for (int i = 0; i < s.length(); i++) {
        char ch = s.charAt(i);
        if (ch >= 'A' && ch <= 'Z') {
            upperCase += ch;
        } else {
            lowerCase += ch;
        }
    }
    return lowerCase + upperCase;
}