When to use queue over arraylist

Question

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?

score 18 · Answer 1 · answered Jul 02 '13 at 22:05

18

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.

answered Jul 02 '13 at 22:05

Daniel Kaplan

62,768
50
234
356

So in this sense the queue is actually restricting what ArrayList already gave us...it is not adding any new feature. What you can do with queue you can do with arraylist (a.k.a random access)...but not vice versa – Victor Jul 02 '13 at 22:14
5

It depends on how you look at it. If you were trying to implement a grocery store line in code, an `ArrayList` would be annoying because it doesn't have a way to get the next customer in a way that's as convenient as a `Queue`. You'd have to do `if (!list.isEmpty()) list.remove(0);`. I'd rather read/write `queue.poll()` – Daniel Kaplan Jul 02 '13 at 22:17
Why Arraylist cannot get next customer easily? We just define an iterator and do iter.next() – Victor Jul 03 '13 at 02:51
1

That's not as easy, expressive and readable as `queue.poll()`. You *can* use an `ArrayList` for this. Nobody is saying otherwise. It's just not the right tool for the job. – Daniel Kaplan Jul 03 '13 at 03:08

score 17 · Accepted Answer · edited Feb 19 '14 at 20:00

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.

Trevor Freeman · Answer 3 · 2014-02-19T18:12:36.803

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.

I had never considered the concurrency. But you're right, you could have 10 threads working on the same queue doing something on the .dequeue() return value, while guaranteed that two different threads won't have the same value. — BenMcLean981, Sep 16 '22 at 13:13

score 1 · Answer 4 · answered Jul 02 '13 at 22:43

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.

score 1 · Answer 5 · answered Dec 03 '15 at 11:50

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

score 0 · Answer 6 · answered Jul 02 '13 at 22:05

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.

score 0 · Answer 7 · answered May 09 '17 at 18:48

0

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

answered May 09 '17 at 18:48

Muhammad Ahmed AbuTalib

4,080
4
36
59

When to use queue over arraylist

7 Answers7

Linked