How to create a fixed size ArrayList with few functionalities as follows..

[asifzbaig]

Hello everyone,
This simple question rolling in my mind without a correct answer,
I want to have a ArrayList with fixed size of 10,
I know i can use array in this situation but they don't provide me methods like add(), set(), remove()..
Now what i want from this particular ArrayList that it holds only LATEST 10 objects entered,
more precisely i mean that that when the size of list reached to 10 than the LAST element must be discarded in favour of the NEW one.

How can i achive this?

[Norm]

Write your own class that extends ArrayList and make it work the way you want.
Or write your own class using an array to hold the data.

[quad64bit]

it holds only LATEST 10 objects entered

Sounds like you want a stack. A stack will always keep the newest items at the top, and with some custom work, you can limit it's size and make it drop elements off the end. Implementing one from scratch really isn't difficult at all, and would really only involve about a page of code. For something this small, I would use a linked structure as opposed to an array based stack. That eliminates shuffling when you insert or remove elements.

You could also subclass one of the java stack implementations, but that might actually be more work if you are unfamiliar with the code or if the code does a lot more than you need. If you need pointers on this, I can site you some pseudo code and method descriptions! :D

[JosAH]

Sounds like you want a stack.

A queue.

kind regards,

Josd

[ozzyman]

A queue.

kind regards,

Josd

You remind me of my school classes.

I guess its a queue because its first-in first-out. and a stack would be first-in last-out.

[JosAH]

You remind me of my school classes.

I guess its a queue because its first-in first-out. and a stack would be first-in last-out.

Yep, and if you read the API documentation for the Queue interface you'll see that one of the implementing classes is the LinkedList class; it has a removeFirst/Last and an addFirst/Last method (so you can have a queue both ways). Before insering check its size() method and drop one of the elements if it contains the maximum number of elements already.

kind regards,

Jos

ps. I don't look like one of your teachers do I? ;-)

[ozzyman]

Hah you wish josah. They were both like 20 years younger than you :p.

But no it just reminded me of my a level lessons when we had to convert pascal to assembler and then trace the stack and we learnt the difference between a stack and a queue.

[JosAH]

Hah you wish josah. They were both like 20 years younger than you :p.

I'm mentally six years old with no noticeable improvement, so I don't know what you're talking about ;-)

kind regards,

Jos

[asifzbaig]

Thanks everyone, and queue implementation does the work.. :)

[JosAH]

Thanks everyone, and queue implementation does the work.. :)

Too bad an ArrayList (as per your requirements) doesn't implement the Queue interface.

kind regards,

Jos

[asifzbaig]

My implementation:

public class QueueList<E> extends LinkedList<E> {
    private int maxSize;

    public QueueList(int maxSize) {
        this.maxSize = maxSize;
    }
    
    @Override
    public boolean add(E e) {
        super.addFirst(e);
        if (size() > maxSize){
            removeLast();
        }
        return true;
    }
}

Here is the reference.

Any improvements in this?

One thing is, i can also use

while (size() > maxSize)

in place of

if (size() > maxSize)

[JosAH]

It is not an ArrayList (see your own topic title).

kind regards,

Jos

[asifzbaig]

It is not an ArrayList (see your own topic title).

Its the outcome that matters Sir. Isn't it?
And from the above replies, i came to the conclusion that queue implementation with LinkedList is the correct way to go.
That is a different thing that I CAN'T USE ANYTHING EXCEPT ArrayList, but here there is no such problem.. :)
and i am here for your suggestions that help me to go to right way and it is what i got..


P.S. : Sorry with the title, i'll take care of it next time

[JosAH]

Ok, if your teacher is happe with a LinkedList, who am I to object?

kind regards,

Jos

[quad64bit]

I know this is late, I was out of town, but I did in fact mean a stack. The newest item would always be on the top, and older items could drop off the bottom. :D

[JosAH]

I know this is late, I was out of town, but I did in fact mean a stack. The newest item would always be on the top, and older items could drop off the bottom. :D

That's a queue.

kind regards,

Jos

[quad64bit]

Queue is FIFO meaning that if I were to insert 5 items, the first out would not be the newest item, but the oldest (the first enqueued). Stack is LIFO meaning the newest item inserted would be the first out. A stack would always give you the most recently inserted items first. If you were keeping a list of 10 newest, popping items off a stack would give them to you newest to oldest. If the stack were implemented with a linked structure, then any items pushed on beyond 10 (the OP's requirement) would also drop the tail element. The resulting list would once again be the 10 latest.

With a queue, it would be similar, but you would be dropping the head, and would end up with the 10 newest items in reverse, oldest to newest.

[JosAH]

Queue is FIFO meaning that if I were to insert 5 items, the first out would not be the newest item, but the oldest (the first enqueued). Stack is LIFO meaning the newest item inserted would be the first out. A stack would always give you the most recently inserted items first. If you were keeping a list of 10 newest, popping items off a stack would give them to you newest to oldest. If the stack were implemented with a linked structure, then any items pushed on beyond 10 (the OP's requirement) would also drop the tail element. The resulting list would once again be the 10 latest.

With a queue, it would be similar, but you would be dropping the head, and would end up with the 10 newest items in reverse, oldest to newest.

That is exactly what the OP wants:

Now what i want from this particular ArrayList that it holds only LATEST 10 objects entered,

New elements are pushed on one side and older elements pop off from the ther side; i.e. a queue.

kind regards.

Jos

[j2me64]

i've implemented a generic class that should work for any object. the key point of the code is the list.remove(0) where the first element is removed and all elements are moved forward and the new element is added at the end, something like a FIFO aka queue. my test is poor: i added three elements 1, 2 and 3 to the arraylist and then i added 4, 5 and 6 to the list and after add() i prompted the content of the list. here is the code:

import java.util.ArrayList;
import java.util.List;

public class MyArrayList<T> {
	private List<T> list;
	private int maxSize;
	
	
	public MyArrayList(int maxSize) {
	
	this.maxSize = maxSize;
	list = new ArrayList<T>(maxSize);
	}
	
	// something like a queue
	public void add(T t) {
		if (list.size() == maxSize) {
		// remove first element
		list.remove(0);
		// add the new element at the very back
		// maxSize is not zero based, so make it zero based by -1
		  list.add(maxSize - 1, t);
		} else if (list.size() < maxSize){
			list.add(t);
		}
	}
	
	public int size() {
		return list.size();
	}
	
	public String toString() {
		return list.toString();
	}
	
	public static void main(String[] args) {
		// the list can have 3 elements of type integer
		MyArrayList<Integer> list = new MyArrayList<Integer>(3);
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);
		list.add(4);
		System.out.println(list);
		list.add(5);
		System.out.println(list);
		list.add(6);
		System.out.println(list);
	}
}

watch out: the class MyArrayList holds an ArrayList which has also methods like add(), so when you want to use the add() from the ArrayList use list.add(). the output is plausible

[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]

but any feedback is welcome. perhaps inside MyArrayList a Queue would be more suitable for this problem.

[JosAH]

All that juggling in you add( ... ) method isn't necessary; the following will do fine:

public void add(T t) {        
   if (list.size() == maxSize)         // remove first element
        list.remove(0);        
   // add the new element at the very back
   list.add(t);        
}

kind regards,

Jos