Question

我一直在尝试将这些数字转换为8个字符串。

我遇到了一些麻烦，因为左边的零被忽略了。例如。

预期结果：00111111 结果我得到了：111111

这是我的代码：

    String s = new String("xlactz3Ja8Z/qep6niE");

        System.out.println("String: " + s);

        byte[] b = Base64.getDecoder().decode(s);
        String res = "";

        for(byte a : b)
        {
            int num = 255 & a; //Tool for set only 8 bits for time
            res = res + " " + Integer.toString(num, 2);
        }

        System.out.println();
        System.out.println(res);

        res = res.trim();

        transform(res, 0);

    }

    private static void transform(String s, int i)
    {
        String aux = new String();
        String newString = new String ();

        char[] v = s.toCharArray();

        for(int i1 = i; i1 < s.length(); ++i1)
        {
            if(v[i1] != ' ')
            {
                aux = aux + v[i1];
            }
            else
            {
                if(aux.length() == 8)
                {
                    newString = newString + aux + " ";
                    aux = "";
                }
                else
                {
                    for(int j= 0; j < 8 - aux.length(); ++j)
                        aux = "0" + aux;

                    newString = newString + aux + " ";

                    aux = "";                   
                }
            }
        }

        System.out.println(newString);
    }
}

代码的预期输出：

11000110 01010110 10011100 10110111 00111101 11001001 01101011 11000110 01111111 10101001 11101010 01111010 10011110 00100001

Answer 1

也许，不是使用转换功能，你可以在循环中做这样的事情 -

for (byte a : b) {
    int num = 255 & a; // Tool for set only 8 bits for time
    res = res + " " + String.format("%08d", Integer.parseInt(Integer.toString(num, 2)));
}

Answer 2

这个循环不适合你：

for(int j= 0; j < 8 - aux.length(); ++j)
    aux = "0" + aux;

因为在每个迭代步骤中，aux的长度发生变化，因此限制改变了。事实上，限制变小了，所以如果需要预先添加2个或更多字符，循环将比你需要的更早退出。

像这样改写：

for (int j = aux.length(); j < 8; ++j)
    aux = "0" + aux;

这具有额外的好处，即aux.length()仅被调用一次。它实际上是您算法当前功能的关键。

另一个问题是s中的最后一个值不会被追加。要解决这个问题，您需要在代码中的主循环之后添加完全相同的循环。像这样：

    for (int i1 = i; i1 < s.length(); ++i1) {
        if (v[i1] != ' ') {
            aux = aux + v[i1];
        } else {
            if (aux.length() == 8) {
                newString = newString + aux + " ";
                aux = "";
            } else {
                for (int j = aux.length(); j < 8; ++j)
                    aux = "0" + aux;

                newString += aux + " ";

                aux = "";
            }
        }
    }

    for (int j = aux.length(); j < 8; ++j)
        aux = "0" + aux;

但是这段代码确实非常糟糕。使用位移实现二进制字符串生成会更好。考虑一下：

private static String toBinaryString(int num, int width) {
    char[] bits = new char[width];
    for (int i = width - 1; i >= 0; i--) {
        bits[i] = (char)('0' + (num & 1));
        num >>= 1;
    }
    return new String(bits);
}

您可以使用要转换的数字作为第一个参数调用此方法，将第8个作为第二个参数调用。借助此功能，你可以放弃transform功能，并在第一个函数的中间更改循环，如下所示：

for (byte a : b) {
    int num = 255 & a;
    res += " " + toBinaryString(num, 8);
}

将每个二进制数转换为8个字符的字符串

2 个答案: