CODEWITHSUNDEEP
javaarraylistqueue
Victor
Victor

Reputation: 17097

When to use queue over arraylist

One basic argument to use a Queue over an ArrayList is that Queue guarantees FIFO behavior.

But if I add 10 elements to an ArrayList and then iterate over the elements starting from the 0th element, then I will retrieve the elements in the same order as they were added. So essentially, that guarantees a FIFO behavior.

What is so special about Queue as compared to traditional ArrayList?

Upvotes: 25

Views: 38393

Answers (7)

Muhammad Ahmed AbuTalib
Muhammad Ahmed AbuTalib

Reputation: 4302

Consider a situation in which random processes update an arraylist randomly and we are supposed to process them in fifo?

There is absolutely no way to do that but to change the data structure from arraylist to queue

Upvotes: 0

Ankish
Ankish

Reputation: 11

Yes!

I would have used poll() and peek() methods in queue which returns the value as well as remove , examine head element respectively .Also These methods provides you with a special value null if the operation fails and doesn't throws an exception as with remove() method will throw nosuchelement exception.

Ref: docs.oracle.com

Upvotes: 1

Lee Martie
Lee Martie

Reputation: 186

If I gave you a Queue instance then you would know that by iteratively calling remove() you would retrieve the elements in FIFO order. If i gave you an ArrayList instance then you can make no such guarantee.

Take the following code as an example:

        ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);
    list.add(4);
    list.add(3);
    list.add(2);
    list.add(1);


    list.set(4,5);
    list.set(3,4);
    list.set(2,3);
    list.set(1,2);
    list.set(0,1);

    System.out.println(list);

If I were now to give you this list, then my iterating from 0 to 4 you would not get the elements in FIFO order.

Also, I would say another difference is abstraction. With a Queue instance you don't have to worry about indexes and this makes things easier to think about if you don't need everything ArrayList has to offer.

Upvotes: 17

Trevor Freeman
Trevor Freeman

Reputation: 7232

The limitations imposed on a queue (FIFO, no random access), as compared to an ArrayList, allow for the data structure to be better optimized, have better concurrency, and be a more appropriate and cleaner design when called for.

In regards to optimization and concurrency, imagine the common scenario where a producer is filling a queue while a consumers consumes it. If we used an ArrayList for this, then in the naive implementation each removal of the first element would cause a shift operation on the ArrayList in order to move down every other element. This is very inefficient, especially in a concurrent implementation since the list would be locked for duration of the entire shift operation.

In regards to design, if items are to be accessed in a FIFO fashion then using a queue automatically communicates that intention, whereas a list does not. This clarity of communication allows for easier understanding of the code, and may possibly make the code more robust and bug free.

Upvotes: 8

specs
specs

Reputation: 11

The difference is that for a Queue, you are guaranteed to pull elements out in FIFO order. For an ArrayList, you have no idea what order the elements were added. Depending on how you use it, you could enforce FIFO ordering on an ArrayList. I could also design a wrapper for a Queue that allowed me to pull out which-ever element I wanted.

The point I'm trying to make is that these classes are designed to be good at something. You don't have to use them for that, but that's what they are designed and optimized for. Queues are very good at adding and removing elements, but bad if you need to search through them. ArrayLists, on the other hand, are a bit slower to add elements, but allow easy random access. You won't see it in most applications you write, but there is often a performance penalty for choosing one over the other.

Upvotes: 1

Daniel Kaplan
Daniel Kaplan

Reputation: 67390

You can look at the javadoc here. The main difference is a List lets you look at any element whenever you want. A queue only lets you look at the "next" one.

Think about it as a real queue or as a line for the cash register at a grocery store. You don't ask the guy in the middle or the end to pay next, you always ask the guy who's in the front/been waiting the longest.

It's worth noting that some lists are queues. Look at LinkedList, for example.

Upvotes: 19

eternay
eternay

Reputation: 3814

For example, Queue methods poll() and remove() retrieves the element and removes it from the Queue.

Some implementation of Queue interface (PriorityQueue) allow to set a priority to the elements and retrieves them thanks to this priority. It is much more than a FIFO behaviour in that last case.

Upvotes: 0

Related Questions