DrChaos wrote On 10/06/05 13:13,:

   This is probably the root cause of Java's reputation for
slowness: People who do silly things and then blame the language.

   First idea: It's a good thing you provided an example,
because your problem description verges on the baffling.

   Second idea: Is there some special reason you want to
use a collection that's based on compareTo() rather than
on equals()?  TreeMap does so, but unless you actually
need "sortedness" a HashMap is probably preferable.

In Java the typical idiom for maintaining the same collection in
several orders is just to have several arrayLists or arrays  
or Collections with a list of pointers to the objects. there is no
master collection.

You get your sorts  in the first place with Collections.sort and then
an toArray export.

If you want to keep adding elements, you can maintain several
arraylists each using a different comparator.  You can then insert an
elt, or tack it on the end and resort.  I wrote a class called
SortedArrayList that does lazy sorting to make this easier.

See http://mindprod.com/products1.html#SORTED

Thanks for your suggestions and comments.
I built, using TreeMap and a comparable item (with a static sorting
switch) an easily sortable via 2 indexes, a dynamic String array, with
counts.  I no longer need the index back because my
"indexedStrCompareClass.add(...)" function takes care of the count and
duplicated string issues using the TreeMap.  My only other route was to
go with Tables, and as i understand they are very slow in java.

I have not done any performance testing on this yet, but it's
simple,reusable as a basic string counting list and will likely do the job.

The conversion between TreeMap to array should be quick just resetting a
new pointer...

public class treeTerms implements Comparable{
    String term;
    int    count;
    static boolean sortOnString;
    /** Creates a new instance of treeTerms */
    public treeTerms() {
    }

    public int compareTo(Object obj){
            if (sortOnString)
                return (term.compareTo(((treeTerms)obj).term));
            else{
                if (count == ((treeTerms)obj).count)
                    return 0;
                else if (count < ((treeTerms)obj).count)
                    return 1;
                else return -1;
            }
        }

}

--------------------------------------------

import java.io.*;
import java.util.*;

/**
 *
 * @author root
 */
public class indexedStrCompareClass {
    TreeMap t;

    public indexedStrCompareClass(){
       t= new TreeMap();
    }

    public void  add(treeTerms tSet){
        treeTerms setObj = (treeTerms)t.get(tSet.term);
        if (setObj == null)
            t.put(tSet.term, tSet);
        else
            setObj.count +=1;
    }
    public Object remove(treeTerms tSet){
        return t.remove(tSet.term);
    }
    public Object[] getTermSortedArray(){
        TreeSet ts = new TreeSet();
        treeTerms.sortOnString = true;
        ts.addAll(t.values());
        return ts.toArray();
    }

    public Object[] getCountSortedArray(){
        TreeSet ts = new TreeSet();
        treeTerms.sortOnString = false;
        ts.addAll(t.values());
        return ts.toArray();
    }
}

----------------------------