Java ArrayList vs. Open ArrayList Performance

A java array is fixed in size and stores elements of the same datatype within an ordered list. A Java ArrayList, is dynamic and flexible in adding elements.

Digital Quality

8 min

Java applications often utilize data structures that contain ArrayList instances. Every time you iterate an object inside an ArrayList, you must also iterate all the objects stored in that instance, which can lead to performance issues. An OpenArrayList is a class that mimics an ArrayList but often offers better performance.

So, let's explore the ArrayList vs. OpenArrayList argument and help you decide when you should use one over the other.

Java Arrays vs. ArrayLists

A Java array is fixed in size and stores elements of the same datatype within an ordered list.

A Java ArrayList, on the other hand, is dynamic, and it gives you the flexibility to add and remove elements as required.

With that said, an ArrayList is not synchronized, which can cause issues if you're sharing it in a multi-threaded environment without following the proper steps.

Therefore, you should only consider using an ArrayList in Java if:

you are not using a multi-threaded environment
you need to maintain the order in which the elements were inserted
you want to access each element in the fastest way possible
you do not mind the potential of duplicate objects within your ArrayList, and
you do not mind the presence of null elements within your ArrayList

If your project matches all of these criteria, you should be able to use an ArrayList without a second thought.

That's great news because an ArrayList is exceptionally convenient for storing a long list of objects. However, the way you iterate your ArrayList can impact performance.

Moreover, using an ArrayList might be less than ideal if you need to obtain every performance gain possible.

Here are the options available for optimizing an ArrayList for performance and how the performance of each option compares to an OpenArrayList.

Iterating an ArrayList

If you're using a standard ArrayList, you have three options for iterating the objects stored inside the instance:

a for-loop,
a for-each-loop, or
an iterator

Regardless of which option you choose, there's only a tiny amount of performance difference.

Still, if performance is critical to your application, the difference might be enough to justify choosing one option over another.

If you're working with an application where even a minuscule gain in performance would be worthwhile, you should test all three of these methods using Java Microbenchmark Harness to see if there is any difference and if the difference is practical.

In general, the for-each-loop and iterator options are comparable in performance, while the standard for-loop tends to show a minor performance improvement.

If you're testing these various options, be sure to run multiple sets of tests and try multiple sizes of your ArrayList (e.g., one with 10 elements and one with 100) to see how the size of the list affects any performance improvements that one option may offer.

Of course, if performance is definitely a concern, it's worth exploring the option of using an OpenArrayList.

Iterating an OpenArrayList

The OpenArrayList class mimics an ArrayList, and it does so in a straightforward, streamlined manner. When comparing an OpenArrayList to an ArrayList with the same elements, the OpenArrayList is nearly 1% faster for 100 elements and about 5% faster for 10 elements.

An OpenArrayList is rightfully named because the member variables are not private, meaning anyone in the outside world can see them.

Keeping the variables open is essential to noticing any performance gain, as it allows you to access the elements array directly, which makes iterating the elements a little bit faster.

Making the elements array public means you can also use System.arraycopy() to write to it or copy from it, which is extremely fast.

Improving Performance for Your Java Application

If you're considering the performance differences of various ArrayList configurations, you're likely working with an application where performance is highly critical.

Fortunately, there are countless ways to improve the performance of your Java application that go far beyond using an OpenArrayList or testing a different iteration method.

Improving Java application performance begins with clean coding and following the best practices of Java development.

Of course, those things are much easier said than done, and many teams find themselves inheriting processes or applications that simply don't meet the modern standards of clean development practices.

No matter which situation you find yourself in, having the right tools and experts on your side is essential to making progress. You also need to track the right metrics.

Java Performance Metrics

The exact metrics you track in your Java app will vary depending on its complexity, but if you're trying to manage performance, you should consider these key areas:

Response Time: This metric tells you how long it takes for a transaction to complete in your app. You can check this at the database level or the HTTP request level. You can identify the slowest queries and then try to optimize them.
Throughput: Throughput examines transactions to reveal how many requests your app is processing, usually displayed as requests per minute (rpm). Increasing the rpm of your app is a good goal to set.
Load average: This metric reveals results for the last 15, 5, and 1-minute intervals. This number should always be less than the number of cores in your machine. If it exceeds the number of cores, your machine is not operating optimally and is under stress.

Depending on your business goals, you might also try to track metrics like uptime and service health.

What matters is that you define metrics, track them consistently, and set ever-improving benchmarks so that you can keep your eye on performance and achieve optimization.