For example, if I have a HashMap object ‘myHashMap’ that contains <Integer, String> to loop through it:

Set<Integer> keys = myHashMap.keySet();
Iterator<Integer> iterator = keys.iterator();
Integer key;
String value;
while (iterator.hasNext()) {
 key = iterator.next();
 value = myHashMap.get(key);
}

If you want your keys to be ordered in a certain way, use TreeMap instead of HashMap.

Hope this helps!

For example when we initialize an ArrayList we usually do this:

ArrayList myList = new ArrayList();

There’s really nothing wrong with it except that if the number of contents we add inside the ArrayList exceeds the default initial capacity which is ten (10), a larger array is created and the contents of the old array will be passed to the new array. The old array will then be reclaimed by the garbage collector.

This is an expensive process and unnecessary.

The solution?

Try approximating the number of contents that would be contained by your array.

ArrayList myList = new ArrayList(32);

It is better that your array capacity will be bigger than the actual contents than have it smaller.

Hope this helps!

if (myString.equals("") {
    //code
}

This is faster:

if (myString.length() == 0 {
    //code
}

Hope this helps.

for (int i = 0; i < list.size(); i++) {
    //some code here
}

So what’s wrong with it? Well, making the method invocation list.size() as part of the loop will force it to be executed at least as many times as the loop body. This causes unnecessary overhead.

This is a much better way (but should be done with caution):

for (int i = 0; i < size; i++) {
   //some code here
}

Unless the method invocation returns a different value each time it is called, the above method should be done.

Is there danger in doing this? Yes. There was one time when I was editing someone else’s code, in my haste and carelessness due to time pressure, I blindly followed this rule which resulted in an infinite loop!.

int length = list.length();
while (length == 0) {
    //code
}

I didn’t notice the length of the ArrayList was changing each time inside the loop! As you know this is an infinite loop and would cause harm to the application’s performance even a server crash.

But good thing it was fixed before deploying. Lesson learned.

In summary, placing method invocations outside of the loop is an ideal practice but should be done with caution. It will only call the method once rather than calling it as many times as the loop body which saves a lot of overhead and memory.

StringBuffer buffer = new StringBuffer(““);
for (int i = 0; i < size; i++) {
    buffer.append(“Some text here...“);
}

use

StringBuilder builder = new StringBuilder(““);
for (int i = 0; i < size; i++) {
    buffer.append(“Some text here...“);
}

They both have very similar functionalities except that StirngBuffer is synchronized and will cost more overhead compared to StringBuilder w/c is not. StringBuffer on the other hand must be used when there are threading issues.

Avoid using String to concatenate in loops.

ex.

String text = “”;
for (int i = 0; i < size; i++) {
    text += text + “ more text...”;
}

Doing so calls a StringBuffer every time there is a String to concatenate and thus costing extra and unnecessary overhead.

There are a lot of articles out there that you can search through Google explaining this in detail and showing benchmarks.