OrderedList sorted by String length

Question

i am trying to create an orderedlist of strings in ascending order by length. I am a little shacky on comparables this is what i have so far. I think i have to implement the Comparable interface and use length as the comparison in the Word class but im not entirely sure how to do this. So for example lion, pig, crocodile should look like ....
pig
lion
crocodile
in the ordered list... any help is appreciated.
WORD.JAVA
public class Word
     private String word, description;
     private int startPos, direction, used;
     public static final int NOTUSED = 0;
     public static final int USED = 1;
     public static final int DOWN= 0;
     public static final int ACROSS= 1;
     public Word(String w, String d)
          word = w;
          description = d;
          //startPos = num;
          //direction = dir;
          //used = use;
     public void setDirection(int dir)
          direction = dir;
     public int getDirection()
          return direction;
     public void setUsed(int use)
          used = use;
     public int getUsed()
          return used;
     public void setPos(int num)
          startPos = num;
     public int getPos()
          return startPos;
     public String getDescription()
          return description;
     public String getWord()
          return word;
     public String toString()
          String str = "";
          str = word+": "+description;
          return str;
ORDEREDLIST.JAVA
import java.util.*;
public class OrderedLinkedList
     private class LinearNode
          private LinearNode next = null;
          private Comparable element = null;
          public LinearNode(Comparable c)
               element = c;
          public LinearNode getNext()
               return next;
          public void setNext(LinearNode n)
               next = n;
          public Comparable getElement()
               return element;
          public void setElement(Comparable c)
               element = c;
          public String toStringRecursive()
               String result = element.toString();
               if(next == null)
                    return null;
               else
                    return result + " " + next.toStringRecursive();
          public void add(LinearNode node)
               if(node.element.compareTo(next.element) <= 0)
                    node.next = next;
                    next = node;
               else
                    next.add(node);
     private LinearNode first = null;
     private LinearNode last = null;
     private int count = 0;
     public void add(Comparable c)
          LinearNode node = new LinearNode(c);
          if(isEmpty())
               first = node;
               last = node;
          else if(count == 1)//(first == last)
               if(c.compareTo(first.getElement()) > 0) //one in list add to end
                    last = node;
                    first.setNext(last);
               }else                                   //one in list add to start
                    first = node;
               first.setNext(last);
          else if(c.compareTo(first.getElement()) <= 0) //multiple in list add to start
               node.setNext(first);
               first = node;
          }else if(c.compareTo(last.getElement()) > 0) //multiple in list add to end
               last.setNext(node);
               last = node;
          }else
               first.add(node);
          count++;
     public Comparable remove(Comparable target) throws EmptyStackException,NoSuchElementException
          if(isEmpty())
               throw new EmptyStackException();
          boolean found = false;
          LinearNode previous = null;
          LinearNode current = first;
          while(current != null && !found)
               if(target.equals(current.getElement()))
                         found = true;
               else{
                    previous = current;
                    current = current.getNext();
          if(!found)
               throw new NoSuchElementException();
          if(size() == 1)
               first = last = null;
          else if (current.equals(first))
               first = current.getNext();
               else if(current.equals(last))
                         last = previous;
                         last.setNext(null);
                    else
                         previous.setNext(current.getNext());
          count--;
          return current.getElement();
     public boolean isEmpty()
          return count == 0;
          //return first == null;
     public String toString()
          String result = "";
          LinearNode current = first;
          while(current != null)
               result += current.getElement();
               current = current.getNext();
          return result;
     public int size()
          return count;
}

Answer 1

That's rather a lot of code - and much of it has nothing obvious to do with sorting strings by length. Also I can't see where you have implemented the Comparable interface.
You are talking about java.lang.Comparable, right? In that case some class (Word?) has to be declared as "implements Comparable".
Another way to do this is is to have an instance of Comparator that you use when you create an ordered collection like a TreeSet.
Have you read the JavaWorld article: [http://www.javaworld.com/javaworld/jw-12-2002/jw-1227-sort.html]. It is rather old now and doesn't make any use of generics. But it gives examples of a simple collection - a list - being sorted using Collections.sort(). Both the Comparable and Comparator approaches are illustrated