comparable

I'm trying to sort a simple list of objects by a long - the below isn't working because one of the long strings is pushed to the top simply because it starts with a lower number. So I'm looking for a way to sort these by the actual long values directly The current obj implementation looks something like the below. In the class I'm using this I call Collections.sort(trees); public class Tree implements Comparable<Tree> { public String dist; //value is actually Long public int compareTo(Tree o) { return this.dist.compareTo(o.dist); } } why not actually store a long in there: public class Tree

I have a franchise class with owner(owner of franchise's name), state(2-character string for the state where the franchise is located), and sales (total sales for the day) public class Franchise implements Comparable <Franchise> { final String owner; final String state; final double sales; protected Franchise(String owner, String state, double sales ) { this.owner = owner; this.state = state; this.sales = sales; } public String toString() { String str = state + ", " + sales + ", " + owner; return str; } public String getState() { return state; } public double getSales() { return sales; }

I'm attempting to create a simple generic node class that conforms to the Comparable protocol so that I can easily compare nodes without accessing their key. When I attempt to write the < and == functions, however, the compiler doesn't seem to like it. The < and == functions expect a type when defining the Node parameters. This was simple in Java where you defined equality and < internally to the class. Swift asks for it globally. Any thoughts ? Example: func < (lhs:Node<E:Comparable>, rhs:Node<E:Comparable>) -> Bool { return lhs.key < rhs.key } func == (lhs:Node<E:Comparable>, rhs:Node<E

Consider this code: public interface Foo extends Comparable<Foo> {} public enum FooImpl implements Foo {} Due to the restrictions of type erasure, I receive the following error: java.lang.Comparable cannot be inherited with different arguments: <Foo> and <FooImpl> I have the following requirements: FooImpl needs to be an enum, because I need to use it as a default value in annotations. The contract of my interface is that it needs to be comparable. I already tried using generic bounds in the interface, but this is not supported in Java. Enums implement Comparable, so FooImpl ends up extending

I'm upgrading some code to Java 5 and am clearly not understanding something with Generics. I have other classes which implement Comparable once, which I've been able to implement. But now I've got a class which, due to inheritance, ends up trying to implement Comparable for 2 types. Here's my situation: I've got the following classes/interfaces: interface Foo extends Comparable<Foo> interface Bar extends Comparable<Bar> abstract class BarDescription implements Bar class FooBar extends BarDescription implements Foo With this, I get the error 'interface Comparable cannot be implemented more