Comment puis-je effectuer une itération sur un objet Itérable quand le type n'est pas connu?

Pour un devoir à la maison, j'ai besoin d'implémenter mon propre PriorityQueue et PriorityQueueSort. J'ai utilisé des génériques pour le faire fonctionner sans la fonction de tri, mais maintenant je suis coincé ici..

public static void PriorityQueueSort(Iterable<?> list, 
    PriorityQueue<?,?> pq) {
  if (!pq.isEmpty()) {
    throw new IllegalArgumentException("Non-Empty PriorityQueue");
  }

  for (Object obj : list) {

  }
}

J'ai besoin de passer dans une liste et un vide PriorityQueue, donc de mon mieux deviner à la façon de le faire est juste au-dessus. Comment dois je m'attaque à ce que je puisse parcourir la liste avec un type inconnu, et ajouter chaque élément de cette liste avec le bon type dans la file d'attente de priorité?


Edit:

Ici sont un peu plus dans les détails, il a été déterminé que je n'ai pas assez d'informations.

J'ai un custom PriorityQueue classe, et d'une Entrée personnalisée classe qui détient une clé de type K, et une valeur de type V.

J'ai besoin d'être en mesure de prendre tout objet iterable liste avec n'importe quel type T et itérer dessus, en prenant chaque article et l'ajouter à un initialement vide PriorityQueue comme une clé avec la valeur null. J'ai donc besoin en permanence d'appel removeMin() sur mon PriorityQueue et l'ajouter dans l'ordre de retour dans la même liste d'objet.

public class PriorityQueue<K extends Comparable<? super K>,V> {
private Entry<K,V> _head;
private Entry<K,V> _tail;
private int _size;
public PriorityQueue() {
this._head = null;
this._tail = null;
this._size = 0;
}
public int size() {
return _size;
}
public boolean isEmpty() {
return (size() == 0);
}
public Entry<K,V> min() {
if (_head == null) {
return null;
}
Entry<K,V> current = _head;
Entry<K,V> min = _head;;
while (current != null) {
if (current.compareTo(min) < 0) {
min = current;
}
current = current.getNext();
}
return min;
}
public Entry<K,V> insert(K k, V x) {
Entry<K,V> temp = new Entry<K,V>(k,x);
if (_tail == null) {
_tail = temp;
_head = temp;
}
else {
_tail.setNext(temp);
temp.setPrev(_tail);
_tail = temp;
}
return temp;
}
public Entry<K,V> removeMin() {
Entry<K,V> smallest = min();
smallest.getPrev().setNext(smallest.getNext());
smallest.getNext().setPrev(smallest.getPrev());
return smallest;
}
public String toString() {
return null;
}
public static <K> void PriorityQueueSort(Iterable<? extends K> list,
PriorityQueue<? super K, ?> queue) {
for (K item : list) {
queue.insert(item, null);
}
list.clear();
}
public static void main(String[] args) {
PriorityQueue<Integer, Integer> pq = 
new PriorityQueue<Integer, Integer>();
pq.insert(4, 2);
pq.insert(5, 1);
System.out.println(pq.min().toString());
}
}
Votre signature est brisé; il me permet d'ajouter un Iterable<Integer> à un PriorityQueue<String>.

OriginalL'auteur agent154 | 2013-03-08