How to sort a vector of objects.

Make your LogError class implement Comparable

public class LogError implements Comparable {
  public int lineNumber;
  public int numberOfTimes;
  ...
  // negative if this < oCompare. positive if this > oCompare
  public int compareTo( Object oCompare) {
      LogError leCompare = (LogError) oCompare;
      if( leCompare.numberOfTimes == this.numberOfTimes) {
        return this.lineNumber - leCompare.lineNumber;
      }
      return leCompare.numberOfTimes - this.numberOfTimes;
  }
}

Now just use the java.util.Collections class to sort your Vector

  Collections.sort( totalsVector);

Even better, put your LogError items into a TreeSet class instead of a Vector, then TreeSet.iterator() returns the LogError elements in sorted order.

To use a TreeSet, you must have things in the set that implement Comparable. Or, you can supply a Comparator class in the constructor.

Make a LogComparator object like CEHJ suggested

  LogComparator lcSorter = new LogComparator();

Then pass the Comparator to the TreeSet, and send your Vector at the TreeSet you create (or get rid of the Vector entirely, and just add LogError items one at a time to the TreeSet.

  TreeSet tsSorted = new TreeSet( lcSorter);
  tsSorted.addAll( totalVectors);

If you want to make the class implement Comparable, but would like to be able to set different sort orders, you could do that in various ways.

Perhaps you could use both ideas. Add a static field which contains a Comparator to LogError. Then use it in the compareTo() method. Even simpler (though less object oriented) would be to use a static int field. Here is an example:

public class LogError implements Comparable {
  public int lineNumber;
  public int numberOfTimes;
  public String date;

  public static int sortBy = LogError.SORT_BY_LINE_NUMBER;
  public static final int SORT_BY_DATE = 1;
  public static final int SORT_BY_LINE_NUMBER = 2;
  // ... add more sort types

  // negative if this < oCompare. positive if this > oCompare
  public int compareTo( Object oCompare) {
      LogError leCompare = (LogError) oCompare;
    public int compareTo( Object oCompare) {
      LogError leCompare = (LogError) oCompare;
      switch( LogError.sortBy) {
         case SORT_BY_LINE_NUMBER:

          if( leCompare.numberOfTimes == this.numberOfTimes) {
            return this.lineNumber - leCompare.lineNumber;
          }
          return leCompare.numberOfTimes - this.numberOfTimes;

         case SORT_BY_DATE:
          if( leCompare.date == this.date) {
            return this.lineNumber - leCompare.lineNumber;
          }
          return this.date.compareTo( leCompare.date);
      }
        ...
      return 0;
    }
}

  Now just do LogError.sortBy = LogError.SORT_BY_DATE;

> I dont like the idea of being locked into one sort type but in the short term it works.

Of course it works. I actually tried it on my own machine before I submitted it.