Adding and removing elements to/from an arraylist?

[Stephan Crandego]

Hi,

I want to add and remove elements from/to an ArrayList whenever it meets a certain limit, e.g: 10. Whenever it meets the limit it should remove the first elements, i.e 0, and will add the new one..
I'm not quite sure how to do it...

ArrayList array = new ArrayList();

array.add(1);
array.add(2);
array.add(3);
array.add(4);
array.add(5);

for (Object a: array){
     if (array.size() == 10){
        history.remove(0);
     }
     System.out.println(a);
}

Can someone please help?

[Peter Muster]

I think what you are looking for is not an ArrayList but a Queue. See here. An implementation of both List and Queue is LinkedList. poll() and offer() might be the methods you want to use.

[Stephan van Hulst]

Like Christian, I think this is better handled by a Queue implementation. I recommend the ArrayBlockingQueue, because you can instantiate it with a fixed capacity, and the offer() method will return false if the queue is full, whereupon you can remove an element.

[Stephan Crandego]

Christian Pflugradt wrote:I think what you are looking for is not an ArrayList but a Queue. See here. An implementation of both List and Queue is LinkedList. poll() and offer() might be the methods you want to use.

Thank you for that information, i will look into it but is there a way i could do that with ArrayList?

[Steffe Wilson]

You can do it like this..

Loop
     if array size >= 10
        remove first element
     endif
     add element
EndLoop

[Peter Muster]

Also make sure you don't add or remove elements to/from the ArrayList while you iterate over it or you might get a ConcurrentModificationException. I'm mentioning this since I can't recognize from your code if you work with one or two lists (what is history?).

[Stephan Crandego]

Christian Pflugradt wrote:Also make sure you don't add or remove elements to/from the ArrayList while you iterate over it or you might get a ConcurrentModificationException. I'm mentioning this since I can't recognize from your code if you work with one or two lists (what is history?).

i meant array.remove(0);

[Peter Muster]

mammshean santiez wrote:

Christian Pflugradt wrote:Also make sure you don't add or remove elements to/from the ArrayList while you iterate over it or you might get a ConcurrentModificationException. I'm mentioning this since I can't recognize from your code if you work with one or two lists (what is history?).

i meant array.remove(0);

Then this will most likely give you troubles. The question is, why do you check the size on every element? If you remove the first element everytime an element is added to the list you should never have more than 10 entries, otherwise it might be better to remove items in a while(array.size() >= 10) loop. Sticking with your example, the code could be like this:

while(array.size() >= 10)
{
    array.remove(0);
}
for (Object a: array)
{
     System.out.println(a);
}

You also mentioned you wanted to add an item to the list when the limit is reached. If you require further help, now might be the time to reveal a bit of background information so we can get a better understanding of what you're actually trying to achieve.

P.S.: Before anyone else points it out. From java 1.5 on you should not list unparametrized collections anymore. Regardless of that you should also aim to implement against interfaces. Apart from that array might not be the best name for a structure that is not an array but a collection. So your first line could look like "List<Integer> arrayList = new ArrayList<>();" in Java 1.7 (in Java 1.5 and 1.6 you would also have to parametrize the instance) or you could use a lambda expression instead of your for loop in Java 1.8.

[Stephan Crandego]

Christian Pflugradt wrote:
You also mentioned you wanted to add an item to the list when the limit is reached. If you require further help, now might be the time to reveal a bit of background information so we can get a better understanding of what you're actually trying to achieve.

I need a queue or arraylist with a fixed size. When I add an element and the queue is full, it should automatically remove the oldest element and add the new one..

[Peter Muster]

mammshean santiez wrote:I need a queue or arraylist with a fixed size. When I add an element and the queue is full, it should automatically remove the oldest element and add the new one..

If you use only the add() method to add elements to your ArrayList (not set or add with index parameter etc.) you could just extend ArrayList and modify the add method to behave like required. This might work (untested):

import java.util.ArrayList;

public class TestList<E> extends ArrayList<E>
{

    private final int limit;
    
    public TestList(int limit)
    {
        this.limit = limit;
    }
    
    @Override
    public boolean add(E e)
    {
        if (this.size() >= this.limit)
        {
            this.remove(0);
        }
        return super.add(e);
    }
}

[Stephan van Hulst]

I wouldn't extend ArrayList, because I think implementing a Collection implies that elements won't get lost upon performing an add() operation.

Instead, make a custom class that is composed of a List instead.

[Peter Muster]

Stephan van Hulst wrote:I wouldn't extend ArrayList, because I think implementing a Collection implies that elements won't get lost upon performing an add() operation.

Instead, make a custom class that is composed of a List instead.

That's why I would use a Queue instead but the question was if it was possible to implement this behaviour using an ArrayList. I agree that implementing your own List is a cleaner way but the effort is also higher than just mis-using an existing implementation to overwrite one method. The deciding factor would probably be the context. Is a clean approach desirable or should it be "quick and dirty"? Is the implementation used for a single use case? Is the thread opener the only developer using this structure or should it be available to others? And so on...

[Stephan van Hulst]

No, my point was that you shouldn't extend any collection type, because in this scenario chances are high that you'd be violating the Collection contract. This is roughly what I would do:

final class GoldfishMemory<E> {

  private final int capacity;
  private final List<E> elements;

  GoldfishMemory(int capacity) {
    if (capacity < 0)
      throw new IllegalArgumentException();
  
    this.capacity = capacity;
    this.elements = new ArrayList<>(capacity);
  }

  /**
   * Remember an element.
   * Remembering an element may cause the memory to forget about a previously remembered element.
   *
   * @param element The element to remember.
   *
   * @return A previously remembered element, if the operation caused the memory to forget about it.
   */
  Optional<E> remember(E element) {
    throw new UnsupportedOperationException("Not implemented yet.");
  }
}