CODEWITHSUNDEEP
javaobjectmethods
Mike
Mike

Reputation: 979

Java, optimal calling of objects and methods

Lets say I have the following code:

private Rule getRuleFromResult(Fact result){
    Rule output=null;
    for (int i = 0; i < rules.size(); i++) {
        if(rules.get(i).getRuleSize()==1){output=rules.get(i);return output;}
        if(rules.get(i).getResultFact().getFactName().equals(result.getFactName())) output=rules.get(i);
    }
    return output;
}

Is it better to leave it as it is or to change it as follows: 

    private Rule getRuleFromResult(Fact result){
    Rule output=null;
    Rule current==null;
    for (int i = 0; i < rules.size(); i++) {
        current=rules.get(i);
        if(current.getRuleSize()==1){return current;}
        if(current.getResultFact().getFactName().equals(result.getFactName())) output=rules.get(i);
    }
    return output;
}

When executing, program goes each time through rules.get(i) as if it was the first time, and I think it, that in much more advanced example (let's say as in the second if) it takes more time and slows execution. Am I right?

Edit: To answer few comments at once: I know that in this particular example time gain will be super tiny, but it was just to get the general idea. I noticed I tend to have very long lines object.get.set.change.compareTo... etc and many of them repeat. In scope of whole code that time gain can be significant.

Upvotes: 1

Views: 273

Answers (4)

Jeff Clites
Jeff Clites

Reputation: 620

Your instinct is correct--saving intermediate results in a variable rather than re-invoking a method multiple times is faster. Often the performance difference will be too small to measure, but there's an even better reason to do this--clarity. By saving the value into a variable, you make it clear that you are intending to use the same value everywhere; if you re-invoke the method multiple times, it's unclear if you are doing so because you are expecting it to return different results on different invocations. (For instance, list.size() will return a different result if you've added items to list in between calls.) Additionally, using an intermediate variable gives you an opportunity to name the value, which can make the intention of the code clearer.

Upvotes: 1

keiki
keiki

Reputation: 3459

In general yes it's probably a tiny bit faster (nano seconds I guess), if called the first time. Later on it will be probably be improved by the JIT compiler either way.

But what you are doing is so called premature optimization. Usually should not think about things that only provide a insignificant performance improvement. What is more important is the readability to maintain the code later on.

You could even do more premature optimization like saving the length in a local variable, which is done by the for each loop internally. But again in 99% of cases it doesn't make sense to do it.

Upvotes: 0

gtwd
gtwd

Reputation: 16

It depends on the type of the data structure that "rules" object is. If it is a list then yes the second one is much faster as it does not need to search for rules(i) through rules.get(i). If it is a data type that allows you to know immediately rules.get(i) ( like an array) then it is the same..

Upvotes: 0

FiReTiTi
FiReTiTi

Reputation: 5884

The only different between the two codes, is that in the first you may call twice rules.get(i) if the value is different one one.

So the second version is a little bit faster in general, but you will not feel any difference if the list is not bit.

Upvotes: 0

Related Questions