Java：如何以排序方式迭代 LinkedList？答案

【问题标题】：Java: how to iterate on a LinkedList in a sorted way?Java：如何以排序方式迭代 LinkedList？
【发布时间】：2021-12-08 03:19:55
【问题描述】：

是否可以在不排序的情况下检索 LinkedList 的对象？

class MyClass<T> implements Iterable<T> {

    private LinkedList<T> myList = new LinkedList<>();

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {

            @Override
            public boolean hasNext() {
                return false;
            }

            @Override
            public T next() {
                // SHOULD RETURN THE ELEMENTS OF MYLIST IN A SORTED WAY
                return null;
            }

        };
    }
}

在这种情况下，我们可以假设 T 类型的对象有一个用于排序的整数字段

【问题讨论】：

如果hasNext返回false，那么next应该不被调用。

标签： java sorting collections iterator

【解决方案1】：

这是不可能的，除非您创建额外的方法来“即时”排序或将预排序列表存储在另一个对象中（我假设您不想更改原始列表顺序）。

这两种方法都有成本：

您可以保留“当前”索引的索引并在整个列表中查找下一个索引，但这会消耗 CPU
您可以创建列表的私有副本并对其进行排序，然后返回这个新列表，但它会占用更多内存，并且您必须保持新列表更新，以防原始列表的值发生变化。

【讨论】：

【解决方案2】：

简短回答：不。

排序是找到一个运行中的最小值/最大值，如果不遍历列表中的每个元素，您将无法找到它，因此您需要以某种方式对其进行排序，一种方法是通过@987654321 @ 如果您不想对列表本身进行排序，这意味着额外的内存。

@Override
public Iterator<T> iterator() {
    PriorityQueue<T> heap = new PriorityQueue<>(list);
    return new Iterator<T>() {

        @Override
        public boolean hasNext() {
            return !heap.isEmpty();
        }

        @Override
        public T next() {
            return heap.poll();
        }

    };
}

【讨论】：

如果类型'T'没有实现Comparable，则必须在PriorityQueue的构造函数中指定Comparator。

【解决方案3】：

如果T 类型实现Comparable<T>，你可以这样做。

static class MyClass<T extends Comparable<T>> implements Iterable<T> {

    private LinkedList<T> myList = new LinkedList<>();

    @Override
    public Iterator<T> iterator() {
        return myList.stream().sorted().iterator();
    }
}

public static void main(String[] args) {
    MyClass<Integer> obj = new MyClass<>();
    obj.myList.add(2);
    obj.myList.add(0);
    obj.myList.add(1);

    for (int i : obj)
        System.out.println(i);

    System.out.println(obj.myList);
}

输出：

0
1
2
[2, 0, 1]

或者，您可以通过构造函数传递一个比较器。

static class MyClass<T> implements Iterable<T> {

    private LinkedList<T> myList = new LinkedList<>();
    private final Comparator<T> comparator;

    public MyClass(Comparator<T> comparator) {
        this.comparator = comparator;
    }

    @Override
    public Iterator<T> iterator() {
        return myList.stream().sorted(comparator).iterator();
    }
}

【讨论】：