Question

所以我正在制作搜索算法。我正在使用队列来存储我的所有对象

这是我初始化它的方式

Queue<Node> queue = new LinkedList<Node>();

我想比较每个对象中的变量和队列的顺序。我的计划是使用for循环将第一个对象与其他每个对象进行比较，并将具有最低变量的对象发送到队列的前面。然后移动到下一个对象并重复该过程。我的问题是我不确定如何从队列中检索不是队列中第一个对象的对象....

Answer 1

你可以通过队列进行for循环：

for (Node n : queue) {
     do stuff with n   
}

但是，您无法从队列中间删除项目。我可以建议像ArrayList这样的结构吗？

Answer 2

在我看来，最好的方法是使用PriorityQueue。您可以指定Comparator接口的实现，该接口将强制如何在队列中对元素进行排序。

以下是一个例子：

让我们说这是你的Node类：

public class Node {

  // this field will be used to sort in queue
  private int value;

  public Node(int value) {
    this.value = value;
  }

  public int getValue() {
    return value;
  }

  @Override
  public String toString() {
    return "My value is: " + value;
  }
}

以下是将节点添加到队列中的示例：

import java.util.PriorityQueue;
import java.util.Random;

public class QueueExample {

    public static void main(String[] args) {

        Random r = new Random(); 

        // Priority queue with custom comparator
        PriorityQueue<Node> queue = new PriorityQueue<Node>(10, new SampleNodeComparator());

        // adding 100 nodes with random value
        for(int i = 0; i < 100; ++i) {
            queue.add( new Node(r.nextInt(1000)));
        }

        // nodes will be removed from queue in order given by comparator
        while(queue.size() != 0) {
            System.out.println(queue.remove());
        }
    }
}

最重要的部分 - 我们的自定义比较器的实现

import java.util.Comparator;

// our comparator needs to implements Comparator interface
public class SampleNodeComparator implements Comparator<Node> {

    @Override
    public int compare(Node o1, Node o2) {

        /*
        value that should be return from compare method should follow rules:
        if o1 == o2 - return 0
        if o1 > o2 - return any positive value
        if o1 < 02 - return any negative value
         */
        return o1.getValue() - o2.getValue();
    }
}

当您从QueueExample类运行main方法时，您将在控制台上看到从队列中删除的值按Node.value值排序。

Answer 3

使用Queue<E>#peek ()检索对象而不删除它。

一些示例代码：

import java.util.*;
class Example {
    public static void main (String[] args) throws Exception {
        Queue<String> list = new PriorityQueue<>();
        {   // Initialize the Queue
            list.add ("Hello ");
            list.add ("Mrs. ");
            list.add ("DoubtFire! ");
        }

        System.out.println (list);

        // Iterating through the Queue
        String element;
        while ( (element = list.peek()) != null) {
            if (element.equals ("Mrs. ")) {
                System.out.println ("\"Mrs\" found!");
            }
            System.out.println (element);
            list.remove (element);
        }

        System.out.println (list); // Empty by now...
    }
}

输出：

[DoubtFire! , Mrs. , Hello ]
DoubtFire! 
Hello 
"Mrs" found!
Mrs. 
[]

Answer 4

队列接口在迭代或轮询时不保证任何特定顺序，因此理论上这个任务不可能用Queue实现。

Answer 5

看到您对我的评论的回复，我认为在您的情况下，您应该使用PriorityQueue，因为它可以满足您的需要而无需重新发明轮子，这通常是不推荐。

默认情况下，优先级队列将使用compareTo方法的默认实现。假设您有一个复合类型，您有两个选择：

您可以让自定义类实现Comparabale接口，并在那里设置排序逻辑。

或者，您可以传递自己的比较器：

PriorityQueue<..> p = new PriorityQueue<..>(5, new Comparator<..>()
{
    @override
    public int compare(.. type1, .. type2)
    {
       //comparison logic done here.
    }
}

您可以查看this简短教程以获取更多信息。

Java查看队列中的元素

5 个答案: