Well, here’s what the javadoc of the method getBytes():
getBytes
public byte[] getBytes()
Encodes this String into a Sequence of bytes using the Platform’s default charset, storing the result into a new byte array.
The behavior of this method when this string cannot be encoded in the default charset is unspecified. The CharsetEncoder class should be used when more control over the encoding process is required.
Returns:
The resultant byte array
Since:
JDK1.1
Translating into Portuguese:
getBytes
public byte[] getBytes()
Encodes this String in a sequence of bytes using the charset platform standard, storing the result in a new array of bytes.
The behavior of this method when it string cannot be encoded in the charset default is not specified. The class CharsetEncoder should be used when more control over the coding process is required.
Returns:
The array of bytes resultant
Since:
JDK1.1
That is, this method will not serve your purpose! And yes, you may have coding problems.
One way to improve the situation a little is to use the methods getBytes(String charsetName) or getBytes(Charset charset), that allow you to use a charset well defined and avoid relying on charset platform standard. But still, in the case of String cannot be encoded in the Charset specified, the behavior is still unspecified (ie undefined). Normally this will suffice you if you ensure that all Stringused may always be coded in the charset chosen, or else if you just don’t care for the ones that can’t.
With that, your code would be something like this:
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class ConversaoSimples {
// Método main só para testar o método converte.
public static void main(String[] args) {
String minhaString = "João comeu pão com feijão.";
byte[] bytes = converte(minhaString);
System.out.println(Arrays.toString(bytes));
try {
System.out.println(new String(bytes, "UTF-8"));
} catch (UnsupportedEncodingException x) {
throw new AssertionError(x);
}
}
// Método que faz a conversão.
private static byte[] converte(String str) {
try {
return str.getBytes("UTF-8");
} catch (UnsupportedEncodingException x) {
throw new AssertionError(x);
}
}
}
Here’s the way out:
[74, 111, -61, -93, 111, 32, 99, 111, 109, 101, 117, 32, 112, -61, -93, 111, 32, 99, 111, 109, 32, 102, 101, 105, 106, -61, -93, 111, 46]
João comeu pão com feijão.
However, if the detail that the strings which cannot be coded with the charset specified result in arrays of bytes with somewhat undefined behavior make a difference to you, it is best to use the class
CharsetEncoder. Since this is an abstract class (and it makes no sense for you to create subclasses of it), to get instances you will need to use the method newEncoder() class Charset. The class itself Charset is also abstract, and to get an instance of it, use the static method forName(String charsetName).
After acquiring the instance of CharsetEncoder, you may want to reconfigure it with some of your returning methods CharsetEncoder. These methods modify the CharsetEncoder and return it. Input, you do not need to modify it, the default setting will replace the unknown characters by question marks.
After having the CharsetEncoder properly configured, use one of the methods encode of it. The simplest to use is the method encode(CharBuffer in), who receives a CharBuffer and return a ByteBuffer. To get an instance of CharBuffer, use the static method wrap(CharSequence csq) passing as parameter to your String.
After obtaining the ByteBuffer, you can use the method array() to get a array of bytes.
The array of bytes obtained from ByteBuffer may come with a few zeroes at the end, as its size should be a power of 2 (which are used to balance performance with memory usage). These zeros are unfilled values of buffer allocated. You will need to remove these zeros from the end of the array.
Finally, the code gets complicated:
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.util.Arrays;
public class ConversaoComplicada {
// Método main só para testar o método converte.
public static void main(String[] args) {
String minhaString = "João comeu pão com feijão.";
byte[] bytes = converte(minhaString);
System.out.println(Arrays.toString(bytes));
try {
System.out.println(new String(bytes, "UTF-8"));
} catch (UnsupportedEncodingException x) {
throw new AssertionError(x);
}
}
// Método que faz a conversão.
private static byte[] converte(String str) {
try {
Charset c = Charset.forName("UTF-8");
CharsetEncoder ce = c.newEncoder();
// Se você quiser modificar o CharsetEncoder, faça aqui. Por exemplo:
// ce.replaceWith(...);
CharBuffer cb = CharBuffer.wrap(str);
ByteBuffer bb = ce.encode(cb);
byte[] b = bb.array();
return cortaZeros(b);
} catch (CharacterCodingException x) {
throw new AssertionError(x);
}
}
private static byte[] cortaZeros(byte[] array) {
if (array[array.length - 1] != 0) return array;
int inicio = 0, fim = array.length;
while (inicio != fim && inicio != fim - 1) {
int m = (inicio + fim) / 2;
if (array[m] == 0) {
fim = m;
} else {
inicio = m;
}
}
int tamanho = array[inicio] == 0 ? inicio : inicio + 1;
byte[] resultado = new byte[tamanho];
System.arraycopy(array, 0, resultado, 0, tamanho);
return resultado;
}
}
Here’s the way out:
[74, 111, -61, -93, 111, 32, 99, 111, 109, 101, 117, 32, 112, -61, -93, 111, 32, 99, 111, 109, 32, 102, 101, 105, 106, -61, -93, 111, 46]
João comeu pão com feijão.
Ah yes, I’m guessing your String there is no zero character in it, especially at the end of it. If this happens, this above algorithm will be even more complicated.
If you have a Unicode string and you convert it from/to the same specific encoding (say, UTF-8) then the resulting byte sequence will always be the same. Detail: make sure the "getBytes" function of your platform allows you to specify coding, avoid methods that use standard system coding, because that might not be portable. And obviously, don’t use broken methods.
– mgibsonbr
Avelino, did my reply or @mgibsonbr satisfy you? If so, could you accept one of them? Otherwise, there’s something you still want to clear up?
– Victor Stafusa
@Victorstafusa, I ended up accepting your answer as correct by demonstrating how I should use the
.getBytes();more appropriately. But the two answers were very useful (I gave +1 for both) and also very good. Forgive the delay, I’m TCC and I had to analyze them more calmly (and more time).– Avelino