Question

我遇到的问题是将地图中的值和键从最小到最大排序（整数和字符串）。以下是两种方法，首先是值的方法：

public Collection<V> values(){
    Collection<V> coll = new LinkedList<V>();
    for(int i = 0; i < table.length; i++){
        if(table[i] != null){
            for(Entry<K, V> nextItem : table[i]){
                if(nextItem.value != null){
                    if(!coll.contains(nextItem.value)){
                        coll.add(nextItem.value);
                    }
                }
            }
        }
    }
    return coll;
}

预期产出：

120 123 404 911 999

我的输出（基本上保持在地图中的任何位置的顺序）：

911 999 123 120 404

上述方法与点符号一起用于hashTableChain（一个数组的键是按其hashCode排序的，其中数组的索引是linkedLists），它返回给定映射的值。我尝试用Collections.sort（coll）对它进行排序，但是这需要一个与我的知识不兼容的List。是否有与Collection兼容的东西已经排序或可以轻松排序？密钥的方法：

public Set<K> keySet(){
    Set<K> coll = new HashSet<K>();
    for(int i = 0; i < table.length; i++){
        if(table[i] != null){
            for(Entry<K, V> nextItem : table[i]){
                coll.add(nextItem.key);
            }
        }
    }
    return coll;
}

预期产出：

ABC ACTG HTML LOL OMG XYZ

我的输出（基本上保持在地图中的任何位置的顺序）：

XYZ ABC ACTG HTML LOL OMG

我再次尝试使用Collections.sort（coll）无效，无法找到任何方法对其进行排序。

我对java很新，我确信自己忽略了一些东西，在搜索网页一段时间之后，我想我会问。

提前致谢，我非常感谢您的帮助。

根据要求添加：

private static class Entry<K, V> implements Map.Entry<K, V> {

    /** The key */
    private K key;
    /** The value */
    private V value;

    /**
     * Creates a new key-value pair.
     * @param key The key
     * @param value The value
     */
    public Entry(K key, V value) {
        this.key = key;
        this.value = value;
    }

Answer 1

关于第一个示例，您可以将List<V>用于变量coll：

public Collection<V> values(){
  List<V> coll = new LinkedList<V>();
  // do stuff
  Collections.sort(coll);
  return coll;
}

并且是正确的，因为LinkedList实现了List。您必须选择符合您需求的超类型;如果您需要返回已排序的列表，可以在函数中使用List，对它们进行排序并将列表作为Collection返回。

在第二个例子中相同，但使用

Set<K> coll = new TreeSet<K>();

TreeSet实现了SortedSet，一个进一步提供其元素总排序的集合。

Answer 2

在100％的情况下，您所谓的Collection恰好是List。您只需要通过以下方式告诉编译器：

在致电(List<V>)coll或

sort

更改声明List<V> coll= new LinkedList<V>() ;

如果您将123作为值两次，我认为它是正确的，它会在values()的结果中出现两次。

在第二种情况下，我建议使用SortedSet代替HashSet。

请考虑以下代码：

public class Sample<K extends Comparable<K>,V extends Comparable<V>> {

    public static class Entry<A,B> implements Map.Entry<A,B> {
        A key;
        B value;
        public Entry(A key,B value) {
            this.key= key ;
            this.value= value ;
        }
        public A getKey() {
            return this.key ;
        }
        public B getValue() {
            return this.value ;
        }
        public B setValue(B value) {
            return this.value= value ;
        }
    }

    LinkedList<Entry<K,V>>[] table;

    public Collection<V> values(){

        List<V> coll= new LinkedList<V>() ;
        for(LinkedList<Entry<K, V>> e: table ) {
            if( e != null ) {
                for(Entry<K, V> nextItem : e ) {
                    if( nextItem.value != null ) {
                        coll.add(nextItem.value);
                    }
                }
            }
        }
        Collections.sort(coll);
        return coll;
    }
    public Set<K> keySet(){

        Set<K> coll= new TreeSet<K>() ;
        for(LinkedList<Entry<K, V>> e: table ) {
            if( e != null ) {
                for(Entry<K, V> nextItem : e ) {
                    coll.add(nextItem.key);
                }
            }
        }
        return coll;
    }
    public static void main(String... args) {

        Sample<String,Integer> test= new Sample<String,Integer>();
        test.table= (LinkedList<Entry<String,Integer>>[])new LinkedList[1024] ;
        test.table[467]= new LinkedList<Entry<String,Integer>>() ;
        test.table[467].add( new Entry("XYZ",999) ); 
        test.table[467].add( new Entry("ABC",123) ); 
        test.table[678]= new LinkedList<Entry<String,Integer>>() ;
        test.table[678].add( new Entry("ACTG",404) ); 
        test.table[678].add( new Entry("HTML",120) ); 
        test.table[678].add( new Entry("ACTG",404) ); 
        test.table[678].add( new Entry("LOL",123) ); 
        test.table[  2]= new LinkedList<Entry<String,Integer>>() ;
        test.table[  2].add( new Entry("OMG",911) );

        System.out.println( test.values() );
        System.out.println( test.keySet() );
    }
}

如果您希望创建一个通用类，其中将对参数类型的值进行排序，那么它们需要实现接口Comparable。如果他们需要实现接口Comparable，那么在声明你的类时你需要说出来。这就是K extends Comparable<K>和V extends Comparable<V>声明Sample时的原因。当您致电Collections.sort或实例化TreeSet时，这一点尤其重要。两者都要求参数/参数类型为Comparable s（或其子类型）。

我添加的测试用例的结果是正确的：

[120, 123, 123, 404, 404, 911, 999]
[ABC, ACTG, HTML, LOL, OMG, XYZ]

分别

对集合<v>和集合<k> </k> </v>进行排序

2 个答案: