Java 如何颠倒SortedSet的顺序

我想使用以下命令打印地图中的有序列表：

Map<Float, String> mylist = new HashMap<>();

mylist.put(10.5, a);
mylist.put(12.3, b);
mylist.put(5.1, c);

SortedSet<Float> orderlist = new TreeSet<Float>(mylist.keySet());

for (Float i : orderlist) {
    System.out.println(i+" "+mylist.get(i));
}

但是如何按如下相反顺序打印订单列表：

12.3 b
10.5 a
5.1 c

---

尝试使用

NavigableSet

：

 public NavigableSet<E> descendingSet()

public-NavigableSet-downingset（）

像这样：

  SortedSet<Float> orderlist = new TreeSet<Float>(mylist.keySet());
  SortedSet<Float> treereverse = new TreeSet<Float>();
  // creating reverse set
  treereverse=(TreeSet)orderlist.descendingSet();

SortedSet orderlist=新树集（mylist.keySet（））；
SortedSet treereverse=新树集（）；
//创建反向集
treereverse=（TreeSet）orderlist.DegeningSet（）；

---

最后，您可以使用相反的顺序创建

treereverse

。

如果您愿意以相反的顺序将元素存储在

SortedSet

中，您需要做的唯一更改是构造

TreeSet

，使用它可以定制：

Map mylist=newhashmap（）；
mylist.put（10.5，a）；
mylist.put（12.3，b）；
mylist.put（5.1，c）；
SortedSet orderlist=新树集（Collections.reverseOrder（））；
addAll（mylist.keySet（））；
对于（浮动i：订单列表）{
System.out.println（i+“”+mylist.get（i））；
}

---

注意这里的简洁方法是返回一个比较器，它与元素的自然顺序相反。

您也可以尝试以下方法：

    Map<Float, String> mylist = new HashMap<Float, String>();
    mylist.put(10.5, a);
    mylist.put(12.3, b);
    mylist.put(5.1, c);

    SortedSet<Float> orderlist = new TreeSet<Float>(mylist.keySet()).descendingSet();

    for (Float i : orderlist) {
        System.out.println(i+" "+mylist.get(i));
    }

Map mylist=newhashmap（）；
mylist.put（10.5，a）；
mylist.put（12.3，b）；
mylist.put（5.1，c）；
SortedSet orderlist=新树集（mylist.keySet（））.DownlineSet（）；
对于（浮动i：订单列表）{
System.out.println（i+“”+mylist.get（i））；
}

您可以尝试此实现（）：

公共密封类OrderedSet:ICollection
{
专用只读词典；
私有只读链接列表_LinkedList；
公共OrderedSet（）
：此（EqualityComparer.Default）
{
}
专用OrderedSet（IEqualityComparer比较器）
{
_字典=新字典（比较器）；
_linkedList=新建linkedList（）；
}
public int Count=>\u dictionary.Count；
public bool IsReadOnly=>\u dictionary.IsReadOnly；
作废ICollection.Add（T项）
{
增加（项目）；
}
公共空间清除（）
{
_linkedList.Clear（）；
_dictionary.Clear（）；
}
公共布尔删除（T项）
{
var found=\u dictionary.TryGetValue（项，out var节点）；
如果（！找到）
{
返回false；
}
_删除（项）；
_linkedList.Remove（节点）；
返回true；
}
公共IEnumerator GetEnumerator（）
{
返回_linkedList.GetEnumerator（）；
}
IEnumerator IEnumerable.GetEnumerator（）
{
返回GetEnumerator（）；
}
公共布尔包含（T项）
{
返回_dictionary.ContainsKey（项目）；
}
public void CopyTo（T[]数组，int arrayIndex）
{
_CopyTo（数组，arrayIndex）；
}
公共作废新增（T项）
{
如果（_dictionary.ContainsKey（项目））
{
返回；
}
var节点=_linkedList.AddLast（项）；
_添加（项、节点）；
}
公共无效反向（）
{
var head=_linkedList.First；
while（head.Next！=null）
{
var next=头部。next；
_linkedList.Remove（下一步）；
_linkedList.AddFirst（next.Value）；
}
}
}

请注意，这是一个

OrderSet

，它保留了插入顺序，而不是根据某些比较器（例如，字母顺序）对集合进行排序

---

我从中添加了

Reverse（）

方法。

您反对将集合中的项放在另一个数据结构中吗？此外，您是否需要将

SortedSet

中的项目按照它们已经存在的特定顺序进行存储，或者您是否可以按相反顺序存储它们？我只想打印列表。如果有更好的方法，则不需要SortedSet。如果我可以按相反的顺序储存物品，那也没关系。谢谢，太棒了！没问题！；-）

Map<Float, String> mylist = new HashMap<>();

mylist.put(10.5, a);
mylist.put(12.3, b);
mylist.put(5.1, c);

SortedSet<Float> orderlist = new TreeSet<Float>(Collections.reverseOrder());
orderList.addAll(mylist.keySet());

for (Float i : orderlist) {
    System.out.println(i+" "+mylist.get(i));
}

    Map<Float, String> mylist = new HashMap<Float, String>();
    mylist.put(10.5, a);
    mylist.put(12.3, b);
    mylist.put(5.1, c);

    SortedSet<Float> orderlist = new TreeSet<Float>(mylist.keySet()).descendingSet();

    for (Float i : orderlist) {
        System.out.println(i+" "+mylist.get(i));
    }

public sealed class OrderedSet<T> : ICollection<T>
{
    private readonly IDictionary<T, LinkedListNode<T>> _dictionary;
    private readonly LinkedList<T> _linkedList;

    public OrderedSet()
        : this(EqualityComparer<T>.Default)
    {
    }

    private OrderedSet(IEqualityComparer<T> comparer)
    {
        _dictionary = new Dictionary<T, LinkedListNode<T>>(comparer);
        _linkedList = new LinkedList<T>();
    }

    public int Count => _dictionary.Count;

    public bool IsReadOnly => _dictionary.IsReadOnly;

    void ICollection<T>.Add(T item)
    {
        Add(item);
    }

    public void Clear()
    {
        _linkedList.Clear();
        _dictionary.Clear();
    }

    public bool Remove(T item)
    {
        var found = _dictionary.TryGetValue(item, out var node);
        if (!found)
        {
            return false;
        }

        _dictionary.Remove(item);
        _linkedList.Remove(node);
        return true;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return _linkedList.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public bool Contains(T item)
    {
        return _dictionary.ContainsKey(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        _linkedList.CopyTo(array, arrayIndex);
    }

    public void Add(T item)
    {
        if (_dictionary.ContainsKey(item))
        {
            return;
        }

        var node = _linkedList.AddLast(item);
        _dictionary.Add(item, node);
    }

    public void Reverse()
    {
        var head = _linkedList.First;
        while (head.Next != null)
        {
            var next = head.Next;
            _linkedList.Remove(next);
            _linkedList.AddFirst(next.Value);
        }
    }
}