String compression using repeated character counts Implement a method to perform basic string compression using the counts of
  repeated characters. For example, the string aabcccccaaa would become
  a2blc5a3. If the "compressed" string would not become smaller than the original string, your method should return the original string.


Can this be implemented in a better way performance-wise?

package string;

public class CompressChar {

    int[] seq = new int [256];


    public String compressString(String str){

        StringBuffer strComp = new StringBuffer();
        for( char c : str.toCharArray()){
            seq[c]++;
        }
        for (char c : str.toCharArray()){
            if(seq[c]&gt;0){
                strComp.append(c).append(seq[c]);
                seq[c]=0;//so that it does not enter , when char occurs again
            }
        }

        if(str.length()&lt;strComp.length()){
            return str;
        }
        return strComp.toString();

    }
    public static void main(String[] args) {
        CompressChar ch = new CompressChar();
        System.out.println(ch.compressString("abbcdrfac"));
    }
}
Your solution here is wrong, it produces incorrect results when it compresses chars that are in two different places in the string:

For the input: aaaaabbbbbcdrfaaaaaaccccc your program produces:

a11b5c6d1r1f1


when it should produce:

a5b5c1d1r1f1a6c5


Because the a and c repeat in two different places, you include them all in the first count.

Since this is homework, writing out the full solution would be counter-productive, but, if you have:

StringBuilder sb = new StringBuilder();


and two variables to contain the previous char and the previous char count, you could just go through each character in the string, if it's the same as the previous char, you increment the count. If it's different, you add the previous char and it's count to the StringBuilder, and reset the previous and count to 1.

Then, when your loop is done, if the StringBuilder is smaller than the input, return the StringBuilder version.

This type of compression is called 'run length encoding' by the way.