CODEWITHSUNDEEP
java
kralarmerlin
kralarmerlin

Reputation: 35

Is there any difference in optimization between integer and string comparison?

I'm trying to make a game and I have a Selection class that holds a string named str in it. I apply the following code to my selection objects every 17 milliseconds.

if(s.Str == "Upgrade") {
            
}else if(s.Str == "Siege") {
        
}else if(s.Str == "Recruit") {
            
}

In other words, these selection objects will do different jobs according to their types(upgrade,siege etc...). I am using str variable elsewhere. my question is that:
Would it be more optimized if I assign the types to an integer when I first create the objects?

if(s.type == 1) {
                
}else if(s.type == 2) {
            
}else if(s.type == 3) {
            
}

This would make me write extra lines of code(Since I have to separate objects by type when I first create) and make the code more difficult to understand, but would there be a difference between comparing integers rather than comparing strings?

Upvotes: 2

Views: 1016

Answers (4)

Basil Bourque
Basil Bourque

Reputation: 338740

The Answer by Stephen C is correct and wise. But your example code is ripe for a different solution entirely.

Enum

If you want performance, type-safety, easier-to-read code, and want to ensure valid values, use enum objects rather than mere strings or integers.

public enum Action { UPGRADE , SIEGE , RECRUIT }

You can use a switch for the various enum possible objects.

  Action action = Action.SIEGE ;
  …

  switch ( action ) 
  {
     case UPGRADE:
        doUpgradeStuff() ;
        break;
     case SIEGE:
        doSiegeStuff() ;
        break;
     case RECRUIT:
        doRecruitStuff() ;
        break;
     default:
        doDefaultStuff() ;
        break;
  }

Using enums this way will get even better in the future. See JEP 406: Pattern Matching for switch (Preview).

See Java Tutorials by Oracle on enums. And for an example, see their tutorial using enums for month, day-of-week, and text style.

See also this Question, linked to others.

Upvotes: 1

Stephen C
Stephen C

Reputation: 718866

If you compare strings >that< way, there is probably no performance difference.

However, that is the WRONG WAY to compare strings. The correct way is to use the equals(Object) method. For example.

  if (s.Str.equals("Upgrade")) {

Read this:

I apply the following code to my selection objects every 17 milliseconds.

The time that it will take to test two strings for equality is probably in the order of tens of NANOseconds. So ... basically ... the difference between comparing strings or integers is irrelevant.

This illustrates why premature optimization is a bad thing. You should only optimize code when you know that it is going to be worthwhile to spend your time on it; i.e. when you know there is going to be a pay-off.

So should I optimize after I write and finish all the code? Does 'not doing premature optimization' means that?

No it doesn't exactly mean that. (Well .. not to me anyway.) What it means to me is that you shouldn't optimize until:

  1. you have a working program whose performance you can measure,
  2. you have determined specific (quantifiable) performance criteria,
  3. you have a means of measuring the performance; e.g. an appropriate benchmarks involving real or realistic use-cases, and
  4. you have good a means of identifying the actual performance hotspots.

If you try to optimize before you have the above, you are likely to optimize the wrong parts of the code for the wrong reasons, and your effort (programmer time) is likely to be spent inefficiently.

In your specific case, my gut feeling is that if you followed the recommended process you would discover1 that this String vs int (vs enum) is irrelevant to your game's observable performance2.

But if you want to be more scientific than "gut feeling", you should wait until you have 1 through 4 settled, and then measure to see if the actual performance meets your criteria. Only then should you decide whether or not to optimize.

1 - My prediction assumes that your characterization of the problem is close enough to reality. That is always a risk when people try to identify performance issues "by eye" rather than by measuring.
2 - It is relevant to other things; e.g. code readability and maintainability, but I'm not going to address those in this Answer.

Upvotes: 6

Karanjot Singh
Karanjot Singh

Reputation: 156

Yes there is difference. String is a object and int is a primitive type. when you are doing object == "string" it is matching the address. You need to use equals method to check the exact match.

Upvotes: 0

Navjot
Navjot

Reputation: 1294

Comparing primitive numbers like Integer will be definitely faster compared to String in Java. It will give you faster performance if you are executing it every 17 milliseconds.

Upvotes: 0

Related Questions