Using bytes or chars for String phonetic algorithm?

Question

Hi all. I'm working on a phonetic algorithm, much like Soundex.
Basically the program receives a String, read it either char by char or by chunks of chars, and returns its phonetic version.
The question is which method is better work on this, treating each String "letter" as a char or as a byte?
For example, let's assume one of the rules is to remove every repeated character (e.g., "jagged" becomes "jaged"). Currently this is done as follows:
public final String removeRepeated(String s){
                char[] schar=s.toCharArray();
          StringBuffer sb =new StringBuffer();
          int lastIndex=s.length()-1;
          for(int i=0;i<lastIndex;i++){
               if(schar!=schar[i+1]){
                    sb.append(schar[++i]);//due to increment it wont work for 3+ repetions e.g. jaggged -> jagged
          sb.append(schar[lastIndex]);
          return sb.toString();
Would there be any improvement in this computation:public final String removeRepeated(String s){
          byte[] sbyte=s.getBytes();
          int lastIndex=s.length()-1;
          for(int i=0;i<lastIndex;i++){
               if(sbyte[i]==sbyte[i+1]){
                    sbyte[++i]=32; //the " " String
          return new String(sbyte).replace(" ","");
Well, in case there isn't much improvement from the short(16-bit) to the byte (8-bit) computation, I would very much appreciate if anyone could explain to me how a 32-bit/64-bit processor handles such kind of data so that it makes no difference to work with either short/byte in this case.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               

Answer 1

You may already know that getBytes() converts the string to a byte array according to the system default encoding, so the result can be different depending on which platform you're running the code on. If the encoding happens to be UTF-8, a single character can be converted to a sequence of up to four bytes. You can specify a single-byte encoding like ISO-8859-1 using the getBytes(String) method, but then you're limited to using characters that can be handled by that encoding. As long as the text contains only ASCII characters you can get away with treating bytes and characters as interchangeable, but it could turn around and bite you later.
Your purpose in using bytes is to make the program more efficient, but I don't think it's worth the effort. First, you'll be constantly converting between {color:#000080}byte{color}s and {color:#000080}char{color}s, which will wipe out much of your efficiency gain. Second, when you do comparisons and arithmetic on {color:#000080}byte{color}s, they tend to get promoted to {color:#000080}int{color}s, so you'll be constantly casting them back to {color:#000080}byte{color}s, but you have to watch for values changing as the JVM tries to preserve their signs.
In short, converting the text to bytes is not going to do anywhere near enough good to justify the extra work it entails. I recommend you leave the text in the form of {color:#000080}char{color}s and concentrate on minimizing the number of passes you make over it.