Java 为什么当我试图从字符串中删除非中断空格时，却没有得到预期的结果？

我正在编写代码，首先使用换位，然后使用替换来创建密文。到目前为止，我所做的一切都很好（还没有替换），除了从换位中获得的文本包含不间断的空格

在线搜索后，其中一个解决方案是使用

text.replace（“\u00A0”，”）

，这是我在代码中使用的，但它不能帮助我删除那些不间断的空格。非常感谢您的帮助和建议。我将Java与Netbeans IDE 7.4结合使用

public class Cipher {

    static java.util.HashMap<String, String> HMOperators = new java.util.HashMap<String, String>();
    public static char[] Alphabet = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

    /**
     * @param args the command line arguments
     */

    static int locateindex = 0;

    static int[] WhiteSpaceSeparator = new int[100];

    public static String TCipher(String text) 
    {

        char[] stringtoCharArray = text.toCharArray();
        char ch;

        int loc = 0;
        for (int i = 0; i < text.length(); i++) 
        {
            ch = stringtoCharArray[i];

            if (Character.isSpaceChar(ch)) 
        {
            WhiteSpaceSeparator[loc] = i;
        }
        loc++;

        }

        text = text.trim();
        String PlainTextNoSpace = text.replaceAll(" ", "");

        char[] charArray = PlainTextNoSpace.toCharArray();

        int NewIndexArray[] = {2, 7, 5, 3, 0, 4, 6, 1};

        int Rows = 6;
        int Cols = 8;

        char TArray[][] = new char[Rows][Cols];

        int i = 0;


        for (int row = 0; row <= 5; row++) 
        {
             if (i == charArray.length) 
             {
                break;
             }
             TArray[row][NewIndexArray[0]] = charArray[i];  //@ column number index == 2

             if ((i + 1) == charArray.length) 
             {
                break;
             }
             TArray[row][NewIndexArray[1]] = charArray[i + 1]; //@ column number index == 7

             if ((i + 2) == charArray.length) 
             {
               break;
             }
             TArray[row][NewIndexArray[2]] = charArray[i + 2]; //5

             if ((i + 3) == charArray.length) 
             {
                break;
             }
             TArray[row][NewIndexArray[3]] = charArray[i + 3]; //3

            if ((i + 4) == charArray.length) 
            {
                break;
            }
            TArray[row][NewIndexArray[4]] = charArray[i + 4]; //0

            if ((i + 5) == charArray.length) 
            {
                break;
            }
            TArray[row][NewIndexArray[5]] = charArray[i + 5]; //4

           if ((i + 6) == charArray.length) 
            {
                break;
            }
           TArray[row][NewIndexArray[6]] = charArray[i + 6]; //6

            if ((i + 7) == charArray.length) 
            {
                break;
            }
            TArray[row][NewIndexArray[7]] = charArray[i + 7]; //1

            i = i + 8;

        }

        //printing the new 2d array with columns organized in increasing order
        //the new plain text has to be read from the firt column (column 0) to the last one (column 7)
        for (int rows = 0; rows < 6; rows++) 
        {
            System.out.println();
            for (int col = 0; col < 8; col++) 
            {
                System.out.print(TArray[rows][col]);
            }

        }

        //Reading the new plain test per column
        char[] NewTChar = new char[Rows * Cols];

        int k = 0;
        for (int col = 0; col < 8; col++) 
        {
            System.out.println();
            for (int rows = 0; rows < 6; rows++) 
            {
                ch = TArray[rows][col];
                NewTChar[k] = ch;  //storing all the columns into a 1d array to obtain a new text (new cipher)

                k++;

            }

        }

        int n = 0;

        String SeconPlainText = new String(NewTChar);

        SeconPlainText = SeconPlainText.trim();

        SeconPlainText = SeconPlainText.replace("\u00A0", "");  //It does not work, I am not sure why

        System.out.println(SeconPlainText);  

        System.out.println(SeconPlainText);

        StringTokenizer st = new StringTokenizer(SeconPlainText);//it seems like the string is only one token
        while (st.hasMoreTokens()) 
        {
            System.out.println(st.nextToken());  //it prints the whole string, instead of each token
        }
        int a = st.countTokens();

        return SeconPlainText;
    }

    public static void main(String[] args) 
    {

        String PlainText = "Machines take me by surprise with great frequency";

        String Ttext = TCipher(PlainText);

        // SCipher(Ttext);
    }

}

公共类密码{
静态java.util.HashMap HMOperators=new java.util.HashMap（）；
公共静态字符[]字母表={'a'，'b'，'c'，'d'，'e'，'f'，'g'，'h'，'i'，'j'，'k'，'l'，'m'，'n'，'o'，'p'，'q'，'r'，'s'，'t'，'u'，'v'，'w'，'x'，'y'，'z'}；
/**
*@param指定命令行参数
*/
静态int locateindex=0；
静态int[]空格分隔符=新int[100]；
公共静态字符串TCipher（字符串文本）
{
char[]stringtocharray=text.tocharray（）；
char ch；
int loc=0；
对于（int i=0；ifor（int row=0；row我实际上编辑了我的一个for循环，因此当遇到不间断空格时，我必须强制存储实际的空白字符。因此，当字符数组转换为字符串时，我可以稍后使用文本从字符串中删除空白。replace（“，”）；现在，它按预期工作。但是，在IDE（Netbeans）中，“isJavaLetter”被划掉了。我不确定这是否意味着它已被弃用，但它帮助我实现了我想要的。下面是我更新的for循环：

 for (int col = 0; col < 8; col++) 
 {
        System.out.println();
        for (int rows = 0; rows < 6; rows++) 
        {
            ch = TArray[rows][col];

            if(Character.isJavaLetter(ch))//

                NewTChar[k] = ch;  //storing all the columns into a 1d array to obtain a new text (new cipher)
            else
                    NewTChar[k] =' ';   //storing an actual white space character
            k++;

        }

 }

for（int col=0；col<8；col++）
{
System.out.println（）；
对于（int行=0；行<6；行++）
{
ch=柏油树[行][col]；
if（Character.isJavaLetter（ch））//
NewTChar[k]=ch；//将所有列存储到1d数组中以获得新文本（新密码）
其他的
NewTChar[k]=''；//存储实际的空白字符
k++；
}
}
什么是有问题的输入？它可能不是
\u00A0
。非制动是指当你的汽车撞到某物时发生的情况，我想你的意思是不断裂：-）旁注：在Java中，变量名称应该是
camelCase
（小写第一个字母）。您的许多变量都是
TitleCase
，这让Java程序员感到困惑。我突然想到，如果您不想在输出中使用不间断的空格，则需要重新评估转置方法。在事件发生后简单地替换它们是没有用的。这也可能意味着您无法反转加密（因为你没有这些缺失的元素）l。