You don't need to post the library code.

You didn't post yet enough information however.

The code is not a SSCCE (is not compilable).
Where administeredItem is defined?
Why you did not post the loop part?
It's impossible help you if you don't post a code which is compilable.
And it's impossible to help you if the code does not reflect your code
enviroment.

Please read the http://sscce.org and post a SSCEE.

You should also post the Exception stack trace.

Please read in http://mindprod.com/jgloss/newsgroups.html the section
How To Get Newsgroup Responses

Ciao
--
Andrea Francia

On Wed, 14 May 2008 11:32:07 -0700 (PDT), captain
<madison223@gmail.com> wrote, quoted or indirectly quoted someone who
said :

You did not tell us the type of administeredItem.  I assume for
purposes of argument AdministeredItem.

You want something like this:

List<AdministeredItem> adminItems
= new ArrayList<AdministeredItem>( 100 );

 loop:
    adminItems.add(administeredItem);

 Collections.sort(adminItems);

Your class AdministeredItem class will need to implement
Comparable<AdministeredItem>

See http://mindprod.com/jgloss/comparable.html
for how.

If administeredItem is a String then you need

List<String> adminItems
= new ArrayList<String>( 100 );

The piece of code of most interest is the compareTo method of
AdministeredItem.  You did not reveal it yet.

    My code:

    import java.util.ArrayList;
    import java.util.Collections;

    public class Foo {

       public static void main(String[] unused) {
           final int COUNT = 2700;
           ArrayList<Integer> list = new ArrayList<Integer>(COUNT);
           for (int i = 0;  i < COUNT;  ++i)
               list.add(new Integer(
                  (int)(Math.random() * Integer.MAX_VALUE)));
           Collections.sort(list);
       }

    }

Runs like a champ, both as shown and with COUNT = 1000000.

    There's something I'd like you to notice, a difference between
your code and mine: Mine actually runs, while yours won't even
compile.  I can get yours to compile and run by "filling in the
blanks," as it were -- but that probably means that the problem is
in the blanks, the part you still haven't revealed.

    Hint, hint.

Yes, it's a joke, with a point. The point being that we can't find the
problem if you don't show us code that exhibits the problem.

In the unlikely event that Arrays.sort had a bug that showed already
at 2700 elements, and that we knew of it, we could, in theory, guess
that it was that bug you were hitting.

As someone else said, the probability of the bug being in the standard
library vs. the probability of it being in your code suggests that you
should just go ahead and show your code ... or rather show a nicely
reduced example without unnecessary distractions but which still
exhibits the problem.

Often, the act of cutting down to a SSCCE (Small Self-Contained Compilable
Example) will reveal the bug along the way.

Also remember to note which JVM version you are running on. If the bug
is related to the standard library, then that might also be important.

In general, when you need help with a programming problem, you should
provide enough information for us to do the "Three R's". We need to be able
to:
Reproduce the problem: Say what you do. Be precise (give a SSCCE
 that exhibits the problem). Further details are good.
Recognize the problem: Say what happens that you consider as the problem.
 It might be expected behavior. It might not happen to to someone with
 a different configuration.
Repair the problem: Say what you expected to happen. Can't fix the  
 problem if we don't know what to fix it *to*.

/L

If you don't post your code nobody can help you.

Could it be that the comparator must be consistent with equals for the
sort to work?

Phil