Use list.size() or a variable for multiple use ? (local optimization)

I have a simple function called a lot.

Inside this func开发者_如何学编程tion, I have many calls to the size of a list (containing around 10 elements):

list.size()

Is it faster for me to use a temporary variable to get the size only once, or is it faster to call the size() method every time?

Update: it's an ArrayList.

Note: I know what I am doing, I am not looking for a lecture regarding optimization and how it should or shouldn't be done. I am just looking for an answer.

---

It entirely depends on the implementation. You haven't specified the type of list - I assume it's a List<E> or some concrete implementation.

In some implementations such as ArrayList<E> it's extremely cheap - a field access, basically. It's only documented in terms of being constant time, admittedly:

The size, isEmpty, get, set, iterator, and listIterator operations run in constant time.

In others it could potentially be expensive. The interface doesn't provide any guarantees. I would expect it to be cheap (constant time) in most implementations, but you never know for sure...

---

It depends on implementation of the List Looking at the ArrayList's source

/**
  225        * Returns the number of elements in this list.
  226        *
  227        * @return the number of elements in this list
  228        */
  229       public int size() {
  230           return size;
  231       }
  232   

So it doesn't matter if you take a local variable or call this method

---

Check this out (from ArrayList and also LinkedList):

/**
 * Returns the number of elements in this list.
 *
 * @return the number of elements in this list
 */
public int size() {
return size;
}

Calling list.size() is about as efficient as invoking a method and putting a value on the stack: (almost) negligible. Of course you'll be a tiny bit faster using a local (final) variable. If this is an important improvement in the context of your application or not, you will probably have to measure.

---

Regardless of how fast size() method call is. It's a good practice to introduce a variable to carry the result of the method, if that method is invoked multiple times inside a block of code, assuming that the method doesn't change anything.