检查字符串的更好方法？

Question

I have a code that check a string for space,comma and etc. Well since I will deal a scenario where my app will going to check, lets say thousand of string with a max length of 15 and a minimum length of 14. I am worried if it will affect the performance since it is in android. Check the code i used..

private final static char[] undefinedChars = {' ','/','.','<','>','*','!'};

    public static boolean checkMessage(String message){

    if (message == null)
        return false;

    char[] _message = message.toCharArray();

    for (char c : _message) {
         for (int i = 0;i > undefinedChars.length;i++)
                if (c == undefinedChars[i])
                    return true;
    }

    return false;
}

Is this correct? or there is a way to improve it?

Answer 1

There is a change that you could make that might make a little difference:

Change

    char[] _message = message.toCharArray();
    for (char c : _message) {

to

    for (int i = 0; i < message.length(); i++) {
        char c = message.charAt(i);

However, I doubt that it will be significant.

Replacing the inner loop with a switch is more likely to be fruitful, though it depends on what the JIT compiler does with the code. (And a switch will only works if the set of undefined characters can be hard-wired into the switch statement as compile-time constants.)

---

I am worried if it will affect the performance since it is in android.

Don't "worry". Approach the problem scientifically.

1. Implement the code and then benchmark it.
2. If the measured performance is a concern, then:
   1. profile the code
   2. look at hotspots, and identify possible improvements
   3. implement and test possible improvement
   4. rerun the benchmark to see if the improvement actually made any difference
   5. repeat ... until performance is good enough or you run out of options.

---

The other thing to note is that the same code could well perform differently across different Android platforms. The quality of JIT compilers has (apparently) improved markedly in more recent releases.

I would argue that it is a bad idea to "bend" your code just to get it to run well on old phones. The chances are that the user will upgrade their hardware soon anyway ... and it is conceivable that your optimization for the old platform actually makes your code slower on a new platform ... 'cos your hand-optimizations have made the code too tricky for the JIT compiler's optimizer to deal with.

This is also an argument for NOT trying to make your code go "as fast as possible" ...

Answer 2

First of all, I see a bug there.

for (int i = 0;i > undefinedChars.length;i++)

that I think you meant

for (int i = 0;i < undefinedChars.length;i++)

instead?

Anyway it seems that your algorithm runs in O(m*n) where m is the length of message and n is the length of undefined chars(in this case fixed size, 15). Therefore it should be efficient in run-time analysis perspective.

I would profile the scenario first then decide how to improve it, that you could've sorted the message upfront somewhere then you can only check for either 1st char or the last char of the string, but as I said, only if that's been sorted elsewhere.

Or maybe think of parallelizing the routine. It should be straightforward.

Answer 3

Without using memory, you're about as fast as you can get. You can trade memory for performance. For example, you can put the characters you want to check into a HashMap. Then you can loop over the string you're checking, and check if each index is in that map or not. If the number of characters you want to check for is small, this will be less efficient. If the number is big, it will be more efficient (Technically this algorithm is O(n) instead of O(n*m), but if m is small then the constants you're usually taught to ignore will matter).

Another way is to use an array of booleans, with each possible character in the string mapping to an index in that array. Set only the characters you care about to true (and save that array). Then you can avoid the hash calculation above, but at the cost of a lot of memory.

Really, your original algorithm is likely good enough. But these (especially the hash map) are things you can consider if needed.

Answer 4

Try using a regular expression. I find it very clean and it should not hurt your performance.

public static boolean checkMessage(String message)
{
    if (message == null)
        return false;

    String regex = " |\\.|/|<|>|\\*|!";
    Matcher matcher = Pattern.compile(regex).matcher(message);
    if (matcher.find())
        return true;
    else
        return false;
}

Answer 5

For symmetry and possibly some compiler optimization, why not use a for-each style loop for both loops. As an additional benefit, you wouldn't risk a typo like the one pointed out by glaze. Your code would then become:

private final static char[] undefinedChars = {' ','/','.','<','>','*','!'};

public static boolean checkMessage(String message){

if (message == null)
    return false;

char[] _message = message.toCharArray();

for (char c : _message) {
     for (for u : undefinedChars)
            if (c == u)
                return true;
}

return false;

}

An additional optimization would be to order the characters in undefinedChars in the order most likely to occur. That way you'll bail-out as quick as possible.

Answer 6

Use a Set to hold your undefinedChars

Set<Character> undefinedChars = new HashSet<Character>(Arrays.asList(new Character(' ') ,new Character('/'),new Character('.')));

public boolean hasUndefinedChar(String str) {
  for (int i = 0; i < str.length(); i++) {
    char iChar = str.charAt(i);
    Character charWrapper = new Character(iChar);
    if (undefinedChars.contains(charWrapper)) {
      return true;
    }
  }
  return false;
}

This method is O(n) time efficient and does not sufficiently affect space complexity. The contains calls to the Set are O(1) operations and you make n of these contains calls in the worst case.