java - 排序集合并设置

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) 对其进行排序，但是据我所知，这需要一个与 Collection 不兼容的 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>for 变量coll：

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

并且是正确的，因为LinkedList实现List. 您必须选择与您的需求兼容的超类型；如果需要返回排序列表，可以List在函数中使用 a ，对它们进行排序并将列表返回为Collection.

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

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

TreeSetimplements SortedSet，一个 Set ，它进一步提供了对其元素的总排序。

Answer 2

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

1. (List<V>)coll调用前先施法sort，或
2. 更改声明List<V> coll= new LinkedList<V>() ;

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

在第二种情况下，我建议使用 aSortedSet而不是 a 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() );
    }
}

如果您希望创建一个对参数类型的值进行排序的泛型类，那么它们需要实现 interface Comparable。如果他们需要实现 interface Comparable，那么你需要在声明你的类时这么说。这就是为什么K extends Comparable<K>and V extends Comparable<V>while 声明Sample. 当您调用Collections.sort或实例化TreeSet. 两者都要求参数/参数类型是Comparables（或子类型）。

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

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

分别。