我应该使用哪种Java集合类型？

Question

I'm trying to create a "Limited List" in Java. It should remove old entries if I add new entries.

eg If the list size is 3, and I add the 4rd item, it should remove the 1st item. Currently I solved this using remove(0) in a ArrayList , but I heard ArrayList s are very slow.

Is there a faster way to solve this? My current code is:

public class LimitedList<T> extends ArrayList<T> {
    private int maximum;

    public LimitedList(int maximum) {
        this.maximum = maximum;
    }

    @Override
    public boolean add(T t) {
        boolean r = super.add(t);
        while (size() > maximum) {
            remove(0);
        }
        return r;
    }

}

Answer 1

but I heard ArrayList's are very slow.

Some operations are slow for ArrayList s others for other collections. This is because an ArrayList uses an array behind the curtains, and for a remove operation in the head, it has to shift all the elements one to the left. Therefore in terms of big oh, removing from the head is O(n) for ArrayList s where it is O(1) for LinkedList s.

If you only want to add items in the tail of the collection and remove elements in the head, I propose you use a LinkedList :

public class LimitedList<T> extends LinkedList<T> {

    private int maximum;

    public LimitedList(int maximum) {
        this.maximum = maximum;
    }

    @Override
    public boolean add(T t) {
        boolean r = super.add(t);
        int n = this.size();
        while (n > maximum) {
            this.removeFirst();
            n--;
        }
        return r;
    }

}

An important note from @JBNizet is that you should inherit from ArrayList or LinkedList directly, but implement a Collection<T> , something like:

public class LimitedList<T> implements Collection<T> {

    private final LinkedList<T> list;
    private int maximum;

    public LimitedList(int maximum) {
        this.list = new LinkedList<T>();
        this.maximum = maximum;
    }

    @Override
    public boolean add(T t) {
        boolean r = this.list.add(t);
        int n = this.list.size();
        while (n > maximum) {
            this.list.removeFirst();
            n--;
        }
        return r;
    }

    //implement other Collection methods...

}

Answer 2

Please: don't give a nickel on "what you hear". Programming is about hard facts, not hearsay. You can be very sure that all the collection implementations were written by experts in the field; so the first thing would be to check the various documentation out there to assess if the operations that you need really come with a significant performance tag to you. Yes, collection operations have different cost, but all of that is documented.

Then: if you are really only talking about 3, 4 elements ... do you really really think that performance matters? That would only be the case if you would be using this lists for (hundreds of) thousands of times per minute or so. Keep in mind what a modern CPU can do in a few micro seconds nowadays; and how many method calls you need to have in order for "call B is 5 nanoseconds slower" to be noticeable.

In other words: strive for good, clean (SOLID based) designs; instead of worrying about potential performance problems. That will pay off 10 times more compared to spending hours on topics like this.

You see: one should be really careful about "performance issues". Because: you only realize that you have one ... when there are complains from your users. And if that happens, you don't start blindly by trying to improve this or that; no then you first do profiling to measure where your problems are coming from. And then you fix those things that need improvement.

EDIT: so your last comment indicates that you did some sort of measurement (hint: if you would have said so directly, instead of writing "I heard that lists are slow" ... probably you would have gotten a different answers already). OK, lets assume that you did good profiling (where: even when one collection types performs slower for you, the question is still: will it be called so often to cause trouble). Anyway: what you really ant to is to understand access patterns that you do on your code. Do you need random access, do you iterate in lists, etc. You see, typically, a container that forgets elements ... that sounds more like a cache than a list. In that sense: do you rely on quick in-sequence retrieval of objects; or how is data accessed? Those are the questions that you have to ask yourself; and only then you can decide if you should implement your own special limited list; or if there are existing components (maybe from apache commons or guava) that give you what you need.

Answer 3

I think you should use Queues, because this kind of collection use a FIFO procedure (First In - First Out). So the first element you inserted will be the first that goes out and you can manage simply your queue by using methods like Enqueue and Dequeue (both runs in O(1)).

Answer 4

If you are fine with writing code, best option would be not to extend any existing collection and make your own collection. For list, you can implement list interface.( recommended approach is to take AbstractList abstract class)

This will give you more control and you can design for speed.

Fastest option would be to dump the collection and simply use a array (wrap operation in a class). However, that may not be suitable for you as it will not be under collection hierarchy.