Trouble comparing Elements while using Generics

I have a linked list of skipElements(K key, V value) which I need to order based on key. However I don't know how I can compare key since it is a generic.

Even implementing Comparable<skipElement> doesn't seem to work. I tried something like: if (this.key < c.key) return -1; But they're still objects and can't simply be compared with a <. Attempting to cast into int also doesn't seem to work.

if possible post your compateTo method code here. I think the problem is because of object casting.

Code:

---

public class skipElement<K,V> implements Comparable<skipElement>{
    private K key;
    private V value;

    skipElement(K key, V value){
        this.key = key;
        this.value = value;
    }

    public K returnKey(){
        return key;
    }

    public V returnValue(){
        return value;
    }

    public int compareTo(skipElement t) {
        if((int)this.key < (int)t.key)
            return -1;
    }
   
}

---

the error is expected int, found K

Since you defined your key as a generic, the complier doesn't know if the < operator can apply for this element. I think something of this kind could work:

Code:

---

public class MyCollection<K implements Comparable,V> {
  //bla bla bla
}

---

but I am working from memory here, so I'm not sure this works. If it does, you can them compare key of type K with

Code:

---

if(this.key.compareTo(element.key) < 0)

---

In short, when you define a generic, you can set in some restrictions.

Trying that underlines V as a compile error, and still asks me to implement the compareTo method. (no difference except change in "implements..." statement position)

It also still doesn't solve the problem of trying to compare items of type K. I'd like it to be a direct comparison when K is an integer, and number of letters when K is a string. Is there are more accepted method of doing so?

I thought casting would work =/. It seems the only way to tell the compiler from within the class what type K will be.

But that's not the point of generics, if you define something as a generic you don't know what the type will be. That is why you have interfaces, to help you generalize these things. If all you want is ints and strings as your keys, just make a StringKeyMap and IntegerKeyMap with defined behaviour.
By the way, replace implements with extends in the snippet I posted above, just tested it.

I thought the point was to have one class instead of having multiple classes that differ in just one variable type declaration. What if I wanted floats, doubles, or even other objects that needed to be compared?

*I extended K: K extends Comparable. But I'm not sure what I need to do after...

I'm no expert in this, far from it, but I would try something like this:

Code:

---

public class SkipElement<K extends Comparable<K>,V> implements Comparable<SkipElement<K, V>> {
  private K key;
  private V value;

  SkipElement(K key, V value){
      this.key = key;
      this.value = value;
  }

  public K returnKey(){
      return key;
  }

  public V returnValue(){
      return value;
  }

  public int compareTo(SkipElement<K, V> t) {
      return key.compareTo(t.key);
  }

}

---

For this to work, K had better implement Comparable<K>.

Should you use generics in this program?

Since what the OP is trying to do is implement a Map, I believe it would be plain wrong to NOT use generics.

would using a comparator help? Am currently trying out fubarable's code, but someone recommended a comparator

Quote:

---

Originally Posted by ryuzog

would using a comparator help? Am currently trying out fubarable's code, but someone recommended a comparator

---

you will need the comparator if you have to sort one object in multiple ways.

Since you only sort by keys, the Comparable iterface is sufficient. Even if you did have multiple fields by which you sort you could still keep a flag and have the compareTo() made with a switch statement, but that turn nasty very quickly, that's where you would use the Comparator interface.

You need both the implements you currently have and an extends on K:

Code:

---

public class TestMap<K extends Comparable, V> implements Comparable<TestMap> {
    private K key;
    private V value;

    public int compareTo(TestMap o) {
        return this.key.compareTo(o.key);
    }
}

---

This means any key class you use will have to implement Comparable, but this will allow you to define precisely what you want for your Strings, ints, and any others that you decide to use this for.

ETA: And, no. I don;t know why I called it a Map there...:)