Faster way to search linked list?

Question

I'm pretty new to programming and I have to write a kind of psuedo implementation of a cache using a linked list (has to be a linked list). The problem is when I'm setting the maximum size of the linked list to a high number (like 2000), it goes incredibly slow. I don't know how I can make this faster.
Here are the 2 main methods I'm using for it:
public void addObject(Object toAdd){
     cacheList.addFirst(toAdd);
     if(cacheList.size()>=maxAllowedSize){
          removeObject(maxAllowedSize-1);
public boolean containsObject(Object toFind){
     boolean test=false;
     for(int x=0;x<cacheList.size();x++){
          if(toFind.equals(cacheList.get(x))){
               test=true;
               hits++;
               removeObject(x);
               addObject(toFind);
               x=cacheList.size(); //ends for loop
     total++;
     return test;
}Where maxAllowedSize is a command line argument and removeObject just calls cacheList.remove(index).
For testing, I'm using a text file with something over 1.3 million words and using scanner to read them. Here is the code that calls the two methods:
if(!cache.containsObject(currentWord)){
     cache.addObject(currentWord);
}Since containsObject adds the word itself, this calls addObject if the word isn't found (added to the front of the list).
Any help is greatly appreciated.

Answer 1

darkambivalence wrote:
Linked list is what was specified in my assignment.
Then to be honest I expect that part of the learning of assignment is to see how a LinkedList is a poor choice for a list that you want to search.
Why will that run poorly? Because what do you think remove is doing? The remove has to search to find the thing you want to remove. So it's doing that search twice. So it will be twice as slow.
There really isn't much you can do to make this faster. LinkedLists are great for many reasons but "random" accessing (for searching for example) is not one of them. I suppose if one really wanted to squeeze out performance you could keep the list sorted. So when inserting insert into the "right" place in the list and then as you search if a value would fall in between two buckets and doesn't exist in your list you can stop there. A doubly linked list would probably help for this implementation.
In the real world though you would either not use a LinkedList at all or a Map depending on the needs.