using "contains" method from PriorityQueue class

so, I have some nodes that I've put into a PriorityQueue and I want to check to see if a node I have outside the queue is already in the queue. When I use the <priorityqueue>.contains(Node) it seems to run forever (I did some debugging and it's tripping up right on line 91 below). There's quite a bit of code that I'll post below (both the class I'm working with and it's dependent class), but the long and short of my question is: is there a provided means of checking if a node I have outside the PQ is already IN the PQ? If not, any ideas on how to implement a method that does that (pseudo code fine). Any assistance and/or suggestions is appreciated. thanks!

package eightpuzzle;

import java.util.*;

public class a_star{
    int[] goalArray;
    int nodesExpanded = 0;
    int nodesCreated = 0;
    LinkedList<String> path = new LinkedList();
    PriorityQueue<PuzzleNode> openList = new PriorityQueue<PuzzleNode>
            (1,
            new Comparator<PuzzleNode>(){
                public int compare(PuzzleNode a, PuzzleNode b){
                    if (a.getPathCost() > b.getPathCost())
                        return 1;
                    else if (a.getPathCost() < b.getPathCost())
                        return -1;
                    else
                        return 0;
                    }
                }
            );
    PriorityQueue<PuzzleNode> closedList = new PriorityQueue<PuzzleNode>
            (1,
            new Comparator<PuzzleNode>(){
                public int compare(PuzzleNode a, PuzzleNode b){
                    if (a.getPathCost() > b.getPathCost())
                        return 1;
                    else if (a.getPathCost() < b.getPathCost())
                        return -1;
                    else
                        return 0;
                    }
                }
            );

PriorityQueue<PuzzleNode> tempList = new PriorityQueue<PuzzleNode>
            (1,
            new Comparator<PuzzleNode>(){
                public int compare(PuzzleNode a, PuzzleNode b){
                    if (a.getPathCost() > b.getPathCost())
                        return 1;
                    else if (a.getPathCost() < b.getPathCost())
                        return -1;
                    else
                        return 0;
                    }
                }
            );

public a_star(int[] goal, PuzzleNode starter){
        this.goalArray = goal;
        this.openList.clear();
        this.openList.add(starter);
        this.nodesCreated++;
    }

public a_star(){

}

public void findPath(){     // assumes that openList has the starting node already
        closedList.clear();
        tempList.clear();
        PuzzleNode tempNode = new PuzzleNode();
        boolean betterG;
        // while openList is not empty
        while (openList.isEmpty() == false){
            // look at the top of the queue and add node to currentNode = lowest f in openList
            PuzzleNode currentNode = openList.peek();
            // if currentNode contains the goal array, return the successful path
            if (Arrays.equals(currentNode.getPuzzle(), goalArray)){
                System.out.print("The best path is: ");
                currentNode.printDirectionChain();
                System.out.println("The number of nodes expanded was " + this.nodesExpanded);
                System.out.println("The number of nodes created was " + this.nodesCreated);
                break;
            // otherwise push currentNode onto closedList & remove from openList
            } else{ 
                closedList.add(currentNode);
                openList.poll();
            }
            // generate the successors for currentNode and put them in a temporary List
            this.generateSuccessors(currentNode, tempList);
            // loop through the temp list
            int tempListSize = tempList.size();
            for (int j=0; j < tempListSize; j++){
                tempNode = tempList.poll();
                int tmpG = tempNode.getG();
                // check to see if one of the successors to currentNode is already in the openList
                if (closedList.contains(tempNode))
                    continue;
                tmpG = tempNode.getG() + tempNode.getH();
                if (openList.contains(tempNode)==false){
                    betterG = true;
                    // if the currentNode is not in the openList, add it
                    openList.add(tempNode);
                }
                // otherwise, if the successor to currentNode IS in openList
                else if (tmpG < tempNode.getG())
                    betterG = true;
                else
                    betterG = false;
                if (betterG){
                    tempNode.setParentNode(currentNode);
                    tempNode.setG(tmpG);
                    tempNode.setH(currentNode.getH());
                    tempNode.updatePathCost();
                }
            }
            tempList.clear();
        }
    }

// Should pass in the open list, along the node with the lowest value (next one to search from)
    public void generateSuccessors(PuzzleNode n, PriorityQueue pq){
        int[] swapArray = n.getPuzzle();
        int position = 0;

// Loop through the array to get the position of the open box
        for (int i = 0; i < n.getPuzzle().length; i++){
            if (n.getPuzzle()[i] == 0)
                position = i;
        }
        // Based on the position of the open box, generate the next nodes
        if (position == 0){    
            // update the node info, add n as a parent, and add to the tempQueue
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "right"));
            // reset array to original state
            swapArray = n.getPuzzle();
            // update for 2nd possible position (from 0)
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "down"));
        } else if (position == 1){
            swapArray = positionSwap(position, 0, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 2, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "down"));
        } else if (position == 2) {
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 5, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "down"));
        } else if (position == 3){
            swapArray = positionSwap(position, 0, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 6, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "down"));
        } else if (position == 4){
            swapArray = positionSwap(position, 1, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 5, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "right"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 7, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "down"));
        } else if (position == 5){
            swapArray = positionSwap(position, 2, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 8, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "down"));
        } else if (position == 6){
            swapArray = positionSwap(position, 3, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 6, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "right"));
        } else if (position ==7){
            swapArray = positionSwap(position, 4, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 6, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "left"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 8, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "right"));
        } else if (position == 8){
            swapArray = positionSwap(position, 5, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "up"));
            swapArray = n.getPuzzle();
            swapArray = positionSwap(position, 7, swapArray);
            pq.add(this.createSuccessorNode(swapArray, n, "left"));
        }
    }

public PuzzleNode createSuccessorNode(int[] puzzle, PuzzleNode n, String direction){
        PuzzleNode newNode = new PuzzleNode(puzzle, n);
        newNode.setH(n.getH());
        newNode.setG(n.getG()+1);
        newNode.updatePathCost();
        newNode.setDirection(direction);
        this.nodesCreated++;
        return newNode;
    }

public int[] positionSwap(int openP, int targetP, int[] array){
        int[] tmp = array;
        tmp[openP] = tmp[targetP];
        tmp[targetP] = 0;
        return tmp;
    }

public void displayPath(){
        this.path.toString();
    }
}

package eightpuzzle;

import java.util.Arrays;

public class PuzzleNode {
    private int[] puzzleArray;      //representation of the puzzle tiles
    private int hCost;              //represents h(n) in A*
    private int gCost;              //represents g(n) in A*
    private int pathCost;           //represents f(n) in A*
    private PuzzleNode parentNode;  //parent node of the current node
    private String direction;       //tells which direction parent node is

public PuzzleNode(){
    }

public PuzzleNode(int[] pArray, PuzzleNode parentNode){
        this.puzzleArray = pArray;
        this.parentNode = parentNode;
    }

public int[] getPuzzle(){
        return this.puzzleArray;
    }

public void setPuzzle(int[] puzzleArray){
        this.puzzleArray = puzzleArray;
    }

public int getPathCost(){
        return this.pathCost;
    }

public void setPathCost(int pathCost){
        this.pathCost = pathCost;
    }

public int getH(){
        return this.hCost;
    }

public void setH(int hCost){
        this.hCost = hCost;
    }

public int getG(){
        return this.gCost;
    }

public void setG(int gCost){
        this.gCost = gCost;
    }

public void updatePathCost(){
        this.pathCost = this.hCost + this.gCost;
    }

public PuzzleNode getParentNode(){
        return this.parentNode;
    }

public void setParentNode(PuzzleNode pNode){
        this.parentNode = pNode;
    }

public void setDirection(String d){
        this.direction = d;
    }

public void printDirectionChain(){
        PuzzleNode tempNode = this;
        while (tempNode.parentNode != null){
            System.out.print(tempNode.direction + " ");
            System.out.println();
            tempNode = tempNode.parentNode;
        }
    }

}

Please post a shorter bit of code which shows the problem. That is called an SSCCE. You may find more about SSCCEs here.
What does it say in the PriorityQueue documentation?