determine the input type of the value of the function parameter map

[albert kao]

Given the following programs, how to determine the input type of the value of the java.util.Map?

public class MyComboBox extends LangComboBox implements PropertyChangeListener {
  public MyComboBox(Map items) {
      // Is there a way to figure out whether the type of the value (not the key) of the input items is String or MySt?
      // MySt has the method toString()
      // sort items by the input type of the value (not the key) (either String or MySt) of the input items
     //...
  }
}

// Calling program
Map<String, String> map1 = getdata("data1");
MyComboBox box1 = new MyComboBox(map1);
Map<String, MySt> map2 = getdata2("data2");
MyComboBox box2 = new MyComboBox(map2);

If that is not possible, will changing the class definition to something else such as the following achieve my goal?

public class MyComboBox extends LangComboBox implements PropertyChangeListener {
  public MyComboBox(Map<String, ?> items) {
      // is there a way to figure out whether the type of the value (not the key) of the items is String or MySt?
       // sort items by the input type of the value (not the key) (either String or MySt) of the input items
     //...
}

// Calling program
Map<String, String> map1 = getdata("data1");
MyComboBox box1 = new MyComboBox(map1);
Map<String, MySt> map2 = getdata2("data2");
MyComboBox box2 = new MyComboBox(map2);

[Jesper de Jong]

You can use instanceof to check what runtime type an object has.

Object obj = ...;

if (obj instanceof String) {
    System.out.println("It's a String");
} else if (obj instanceof MySt) {
    System.out.println("It's a MySt");
} else {
    System.out.println("It's something else: " + obj.getClass().getName());
}

Note that all objects have a toString() method, because toString() is in class Object.

[Rob Spoor]

Why not add generics to the combo box?

public class MyComboBox<V> extends LangComboBox implements PropertyChangeListener {
  public MyComboBox(Map<String,V> items) {
      // Is there a way to figure out whether the type of the value (not the key) of the input items is String or MySt?
      // MySt has the method toString()
      // sort items by the input type of the value (not the key) (either String or MySt) of the input items
     //...
  }
}

// Calling program
Map<String, String> map1 = getdata("data1");
MyComboBox<String> box1 = new MyComboBox<String>(map1);
Map<String, MySt> map2 = getdata2("data2");
MyComboBox<MySt> box2 = new MyComboBox<MySt>(map2);

If you need to compare on V without wanting to use a java.util.Comparator you can add bounds to it:

public class MyComboBox<V extends Comparable<? super V>> extends LangComboBox implements PropertyChangeListener

Note that the ? super V part is there to allow classes like java.sql.Timestamp - classes that extends another Comparable class.

[albert kao]

Rob Spoor wrote:Why not add generics to the combo box?

public class MyComboBox<V> extends LangComboBox implements PropertyChangeListener {
  public MyComboBox(Map<String,V> items) {
      // Is there a way to figure out whether the type of the value (not the key) of the input items is String or MySt?
      // MySt has the method toString()
      // sort items by the input type of the value (not the key) (either String or MySt) of the input items
     //...
  }
}

// Calling program
Map<String, String> map1 = getdata("data1");
MyComboBox<String> box1 = new MyComboBox<String>(map1);
Map<String, MySt> map2 = getdata2("data2");
MyComboBox<MySt> box2 = new MyComboBox<MySt>(map2);

If you need to compare on V without wanting to use a java.util.Comparator you can add bounds to it:

public class MyComboBox<V extends Comparable<? super V>> extends LangComboBox implements PropertyChangeListener

Note that the ? super V part is there to allow classes like java.sql.Timestamp - classes that extends another Comparable class.

Thank you for your advice!
Please help to solve the following compile error of my test program:
Bound mismatch: The generic method sortByValue(Map<K,V>) of type MapUtil is not applicable for the arguments (Map<String,MyString>). The inferred type MyString is not a valid substitute for the bounded parameter <V extends Comparable<? super V>> MapTest/implementation/src MyComboBox.java line 34

public class MyString {
    String ls;
    
    public MyString() {
    }
    
    public void setEnglish(String s) {
        ls = s;
    }
    
    public String getEnglish() {
        return ls;
    }
    
    public void setFrench(String s) {
        ls = s;
    }
    
    public String getFrench() {
        return ls;
    }
    
    public String toString() {
        return ls;
    }
}

import java.text.Collator;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class MapUtil {
    public static class MapComparable<T>
    implements Comparator<Map.Entry<String, T>>{
        public int compare(Entry<String, T> e1, Entry<String, T> e2) {
            // compare two MyStrings by Collator
            T ls1 = e1.getValue();
            T ls2 = e2.getValue();
            Collator myCollator = Collator.getInstance();
            String s1 = ls1.toString();
            String s2 = ls2.toString();
            return myCollator.compare(s1, s2);
        }
    }
    
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue (
            Map<K, V> map) {
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(
                map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
}

import java.util.HashMap;
import java.util.Map;

public class MyComboBox<V extends Comparable<? super V>> { 
    public MyComboBox(Map<String, V> data) {
        // sort by value (not by key) in the Map & display the result
        HashMap<String, V> sorted_map = (HashMap<String, V>) MapUtil.sortByValue(data);
        for (String key : sorted_map.keySet()) {
            String value = sorted_map.get(key).toString();
            System.out.println("key/value: " + key + "/" + value);
        }
    }
    
    public static void main(String[] args)
    {
        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("key1", "value1");
        map1.put("key2", "value3");
        map1.put("key3", "value2");
        Map<String, String> map1sorted = MapUtil.sortByValue(map1);
        System.out.println(map1sorted);
        MyComboBox box1 = new MyComboBox(map1);
        
        Map<String, MyString> map2 = new HashMap<String, MyString>();
        MyString s1 = new MyString();
        s1.setEnglish("test1");
        MyString s2 = new MyString();
        s1.setEnglish("test2");
        MyString s3 = new MyString();
        s1.setEnglish("test3");
        map2.put("key1", s1);
        map2.put("key2", s3);
        map2.put("key3", s2);
        Map<String, MyString> map2sorted = MapUtil.sortByValue(map2);
        System.out.println(map2sorted);
        MyComboBox box2 = new MyComboBox(map2);
    }
}

[Rob Spoor]

Make MyString implement Comparable<MyString>.

[albert kao]

Rob Spoor wrote:Make MyString implement Comparable<MyString>.

The MyString class is actually a third party class which I don't have the source code so I cannot change it to implement Comparable.
Is there another solution?

[Rob Spoor]

You'll have to drop the extends Comparable<? super V> part and use a Comparator<V>. However, this means that you either have to provide a Comparator<String> if you want a MyComboBox<String>, or you need to sacrifice a bit of type safety - in a similar way to how TreeMap does it. TreeMap allows you to use a non-comparable class as the key type without needing to provide a Comparator, which will cause a ClassCastException during runtime.

import java.text.Collator;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class MapUtil {
    public static class MapComparable<T>
    implements Comparator<Map.Entry<String, T>>{
        public int compare(Entry<String, T> e1, Entry<String, T> e2) {
            // compare two MyStrings by Collator
            T ls1 = e1.getValue();
            T ls2 = e2.getValue();
            Collator myCollator = Collator.getInstance();
            String s1 = ls1.toString();
            String s2 = ls2.toString();
            return myCollator.compare(s1, s2);
        }
    }
    
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue (
            Map<K, V> map) {
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(
                map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    // extra method    
    public static <K, V> Map<K, V> sortByValue (
            Map<K, V> map, final Comparator<V> comparator) {
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(
                map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return comparator.compare(o1.getValue(), o2.getValue());
            }
        });

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
}

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class MyComboBox<V> { 
    // added comparator
    public MyComboBox(Map<String, V> data, Comparator<V> comparator) {
        // sort by value (not by key) in the Map & display the result
        // no need to use HashMap explicitly
        Map<String, V> sorted_map = MapUtil.sortByValue(data, comparator);
        for (String key : sorted_map.keySet()) {
            String value = sorted_map.get(key).toString();
            System.out.println("key/value: " + key + "/" + value);
        }
    }

    // static utility factory method to quickly create a MyComboBox for comparables
    public static <V extends Comparable<? super V>> MyComboBox<V> create(Map<String,V> data) {
        Comparator<V> comparator = new Comparator<V>() {
            public int compare(V v1, V v2) {
                return v1.compareTo(v2);
            }
        };
        return new MyComboBox<V>(data, comparator);
    }    

    public static void main(String[] args)
    {
        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("key1", "value1");
        map1.put("key2", "value3");
        map1.put("key3", "value2");
        Map<String, String> map1sorted = MapUtil.sortByValue(map1);
        System.out.println(map1sorted);
        MyComboBox<String> box1 = MyComboBox.create(map1);
        
        Map<String, MyString> map2 = new HashMap<String, MyString>();
        MyString s1 = new MyString();
        s1.setEnglish("test1");
        MyString s2 = new MyString();
        s1.setEnglish("test2");
        MyString s3 = new MyString();
        s1.setEnglish("test3");
        map2.put("key1", s1);
        map2.put("key2", s3);
        map2.put("key3", s2);
        Comparator<MyString> comparator = ...;
        Map<String, MyString> map2sorted = MapUtil.sortByValue(map2, comparator);
        System.out.println(map2sorted);
        MyComboBox<MyString> box2 = new MyComboBox<MyString>(map2, comparator);
    }
}

[Campbell Ritchie]

If it isn’t a final class you can extend it and make it implement Comparable.
I think combo boxes with generics only work in Java7.

[Winston Gutkowski]

Campbell Ritchie wrote:If it isn’t a final class you can extend it and make it implement Comparable...

And if it is, you might still be able to wrap it in a MyStringWrapper class of your own, and have it implement Comparable.

It all depends on what the class exposes for you, but you might even be able to have your wrapper class implement CharSequence, which would then make it pretty much interchangeable with a String as far as any receiving object is concerned.

Winston

[albert kao]

Rob Spoor wrote:You'll have to drop the extends Comparable<? super V> part and use a Comparator<V>. However, this means that you either have to provide a Comparator<String> if you want a MyComboBox<String>, or you need to sacrifice a bit of type safety - in a similar way to how TreeMap does it. TreeMap allows you to use a non-comparable class as the key type without needing to provide a Comparator, which will cause a ClassCastException during runtime.

Thank you for your advice!
It compiles and runs ok as follows.
However, the commented out class StrComparator has compile error if it is uncommented.
Please help to fix the compile error.
Feel free to suggest any improvement.
Thanks in advance.

public class MyString {
    String ls = "";
    
    public MyString() {
    }
    
    public void setEnglish(String s) {
        ls = s;
    }
    
    public String getEnglish() {
        return ls;
    }
    
    public void setFrench(String s) {
        ls = s;
    }
    
    public String getFrench() {
        return ls;
    }
    
    public String toString() {
        return ls;
    }
    
    public int compareTo(MyString anotherString) {
    	return ls.compareTo(anotherString.toString());
    }
}

import java.text.Collator;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

public class MapUtil {
	/*
        //compile error: The method compareTo(V) is undefined for the type V
	class StrComparator<V> implements Comparator {
		  public int compare(Object o1, Object o2) {
		      V s1 = (V)o1;
		      V s2 = (V)o2;
		      return s1.compareTo(s2);
		  }
		}
	*/	
	
    public static class MapComparable<T>
    implements Comparator<Map.Entry<String, T>>{
        public int compare(Entry<String, T> e1, Entry<String, T> e2) {
            // compare two MyStrings by Collator
            T ls1 = e1.getValue();
            T ls2 = e2.getValue();
            Collator myCollator = Collator.getInstance();
            String s1 = ls1.toString();
            String s2 = ls2.toString();
            return myCollator.compare(s1, s2);
        }
    }
    
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue (
            Map<K, V> map) {
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(
                map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return (o1.getValue()).compareTo(o2.getValue());
            }
        });

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }

    // extra method    
    public static <K, V> Map<K, V> sortByValue (
            Map<K, V> map, final Comparator<V> comparator) {
        List<Map.Entry<K, V>> list = new LinkedList<Map.Entry<K, V>>(
                map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                return comparator.compare(o1.getValue(), o2.getValue());
            }
        });

        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
}

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class MyComboBox<V> { 
    // added comparator
    public MyComboBox(Map<String, V> data, Comparator<V> comparator) {
        // sort by value (not by key) in the Map & display the result
        // no need to use HashMap explicitly
        Map<String, V> sorted_map = MapUtil.sortByValue(data, comparator);
        for (String key : sorted_map.keySet()) {
            String value = sorted_map.get(key).toString();
            System.out.println("key/value: " + key + "/" + value);
        }
    }

    // static utility factory method to quickly create a MyComboBox for comparables
    public static <V extends Comparable<? super V>> MyComboBox<V> create(Map<String,V> data) {
        Comparator<V> comparator = new Comparator<V>() {
            public int compare(V v1, V v2) {
                return v1.compareTo(v2);
            }
        };
        return new MyComboBox<V>(data, comparator);
    }    
    
	class StringComparator implements Comparator {
		public int compare(Object o1, Object o2) {
			if (o1 instanceof String && o2 instanceof String) {
				String s1 = (String) o1;
				String s2 = (String) o2;
				return s1.compareTo(s2);
			}
			return 0;
		}
	}
	
	static class MyStringComparator implements Comparator {
		public int compare(Object o1, Object o2) {
			if (o1 instanceof MyString && o2 instanceof MyString) {
				MyString s1 = (MyString) o1;
				MyString s2 = (MyString) o2;
				return s1.compareTo(s2);
			}
			return 0;
		}
	}

    public static void main(String[] args)
    {
        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("key1", "value1");
        map1.put("key2", "value3");
        map1.put("key3", "value2");
        Map<String, String> map1sorted = MapUtil.sortByValue(map1);
        System.out.println(map1sorted);
        MyComboBox<String> box1 = MyComboBox.create(map1);
        
        Map<String, MyString> map2 = new HashMap<String, MyString>();
        MyString s1 = new MyString();
        s1.setEnglish("test1");
        MyString s2 = new MyString();
        s2.setEnglish("test2");
        MyString s3 = new MyString();
        s3.setEnglish("test3");
        map2.put("key1", s1);
        map2.put("key2", s3);
        map2.put("key3", s2);
        //Comparator<MyString> comparator = new Comparator<MyString>();
        MyStringComparator comparator = new MyStringComparator();
        Map<String, MyString> map2sorted = MapUtil.sortByValue(map2, comparator);
        System.out.println(map2sorted);
        MyComboBox<MyString> box2 = new MyComboBox<MyString>(map2, comparator);
    }
}

[Campbell Ritchie]

Winston Gutkowski wrote: . . . wrap it in a MyStringWrapper class . . . have your wrapper class implement CharSequence, . . .

What good ideas

[Rob Spoor]

albert kao wrote:However, the commented out class StrComparator has compile error if it is uncommented.
Please help to fix the compile error.

	/*
        //compile error: The method compareTo(V) is undefined for the type V
	class StrComparator<V> implements Comparator {
		  public int compare(Object o1, Object o2) {
		      V s1 = (V)o1;
		      V s2 = (V)o2;
		      return s1.compareTo(s2);
		  }
		}
	*/	

V doesn't have a compareTo method, because V is not bound. Change it into this:

    class StrComparator<V extends Comparable<? super V>> implements Comparator<V> {
          public int compare(V o1, V o2) {
              return o1.compareTo(o2);
          }
        }

Note that I also made it implement Comparator<V> which removes the need of casting to V.

[albert kao]

Rob Spoor wrote:

albert kao wrote:However, the commented out class StrComparator has compile error if it is uncommented.
Please help to fix the compile error.

	/*
        //compile error: The method compareTo(V) is undefined for the type V
	class StrComparator<V> implements Comparator {
		  public int compare(Object o1, Object o2) {
		      V s1 = (V)o1;
		      V s2 = (V)o2;
		      return s1.compareTo(s2);
		  }
		}
	*/	

V doesn't have a compareTo method, because V is not bound. Change it into this:

    class StrComparator<V extends Comparable<? super V>> implements Comparator<V> {
          public int compare(V o1, V o2) {
              return o1.compareTo(o2);
          }
        }

Note that I also made it implement Comparator<V> which removes the need of casting to V.

 // compile ok
StrComparator<String> Stringcomparator = new StrComparator<String>();

// compile error
// Bound mismatch: The type MyString is not a valid substitute for the bounded parameter <V extends Comparable<? super V>> of the type
// MyComboBox<V>.StrComparator<V>
StrComparator<MyString> MyStringcomparator = new StrComparator<MyString>();

Currently one Comparator is for String and another Comparator is for MyString.
Is it possible to have a Comparator which allow both String & MyString?

[Rob Spoor]

Sure, but because the two classes have no common super type you'd have to use a Comparator<Object>:

public class ToStringComparator implements Comparator<Object>
{
    public int compare(Object o1, Object o2)
    {
        return o1.toString().compareTo(o2.toString());
    }
}

[Campbell Ritchie]

If MyString implements CharSequence, can you use Comparator<T extends CharSequence> or similar?

[Winston Gutkowski]

Campbell Ritchie wrote:If MyString implements CharSequence, can you use Comparator<T extends CharSequence> or similar?

If it doesn't implement Comprarable, it seems odd that it would implement CharSequence; the authors don't appear to have had ease-of-use high on their list when they wrote it. Or maybe they expect everybody to use toString() if they need one.

OP could help us out by providing its public API...or at least the relevant bits.

Winston

[albert kao]

I simplify the MyComboBox class as follows.
However, please help to fix the compile error.
Bound mismatch: The generic method sortByValue(Map<K,V>) of type MapUtil is not applicable for the arguments (Map<String,V>). The inferred type V is not a valid substitute for the bounded parameter <V extends Comparable<? super V>>

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

public class MyComboBox<V> { 
    public MyComboBox(Map<String, V> data) {
        // sort by value (not by key) in the Map & display the result
        ToStringComparator comparator = new ToStringComparator();
        Map<String, V> sorted_map = MapUtil.sortByValue(data);
        for (String key : sorted_map.keySet()) {
            String value = sorted_map.get(key).toString();
            System.out.println("key/value: " + key + "/" + value);
        }
    }

    static class ToStringComparator implements Comparator<Object>
    {
        public int compare(Object o1, Object o2)
        {
            return o1.toString().compareTo(o2.toString());
        }
    }
    
    public static void main(String[] args)
    {
        Map<String, String> map1 = new HashMap<String, String>();
        map1.put("key1", "value1");
        map1.put("key2", "value3");
        map1.put("key3", "value2");
        MyComboBox<String> box1 = new MyComboBox<String>(map1);
        
        Map<String, MyString> map2 = new HashMap<String, MyString>();
        MyString s1 = new MyString();
        s1.setEnglish("test1");
        MyString s2 = new MyString();
        s2.setEnglish("test2");
        MyString s3 = new MyString();
        s3.setEnglish("test3");
        map2.put("key1", s1);
        map2.put("key2", s3);
        map2.put("key3", s2);
        MyComboBox<MyString> box2 = new MyComboBox<MyString>(map2);
        
        Map<String, MyString> map3 = new HashMap<String, MyString>();
        map3.put("mkey1", s1);
        map3.put("mkey2", s3);
        map3.put("mkey3", s2);
        MyComboBox<MyString> box3 = new MyComboBox<MyString>(map3);
    }
}

[albert kao]

Winston Gutkowski wrote:

Campbell Ritchie wrote:If MyString implements CharSequence, can you use Comparator<T extends CharSequence> or similar?

If it doesn't implement Comprarable, it seems odd that it would implement CharSequence; the authors don't appear to have had ease-of-use high on their list when they wrote it. Or maybe they expect everybody to use toString() if they need one.

OP could help us out by providing its public API...or at least the relevant bits.

Winston

MyString is a third party class which I don't have the source code.
From its original API, I infer that it does not implement CharSequence.
It implements:

boolean equals(Object obj);
boolean equals(MyString obj);
Locale getLocale();
void setLocale(Locale locale);
String getText();
String getText(Locale locale);
String setText(Locale locale, String text);

In the posted code yesterday for the MyString class I implement instead
int compareTo(MyString anotherString);

[Rob Spoor]

albert kao wrote:

        ToStringComparator comparator = new ToStringComparator();
        Map<String, V> sorted_map = MapUtil.sortByValue(data);

You've instantiated a comparator, now use it.

I suggest you go through this before continuing.

[Winston Gutkowski]

Campbell Ritchie wrote:If MyString implements CharSequence, can you use Comparator<T extends CharSequence> or similar?

For the class definition: yes.

If you're using it in a parameterized method where T has already been determined, Comparator<? super T> is more normal.

But we're getting off-topic again. The rozzers'll be on our backs .

Winston

[Winston Gutkowski]

albert kao wrote:It implements:

boolean equals(Object obj);
boolean equals(MyString obj);
Locale getLocale();
void setLocale(Locale locale);
String getText();
String getText(Locale locale);
String setText(Locale locale, String text);

...

In which case, it looks like the answer has been staring at you all along: use its getText() method (whichever seems appropriate).

Or does it do some nefarious reformatting that prevents you?

Winston