Stackoverflow Error when working with larger numbers

Question

I'm trying to write the a* path finding algorithm using recursion and am having trouble. The code finds the path to smaller distances but when I try to use it with larger numbers, I get a stack overflow error. I am new to recursion so there is definitely something I am doing wrong but I can't figure it out. I have an exit condition and it works fine on smaller numbers so I don't know what to do unless I have a problem with the algorithm itself. The problem occurs in the findAlgorithm() method where the recursion is being done.

Algorithm:

Node[][]nodes;
ArrayList<Node> options = new ArrayList<Node>();
ArrayList<Node> path = new ArrayList<Node>();
private int x, y, endX, endY;
Node endNode;

public Algorithm(Node[][]nodes) {
    this.nodes = nodes;
    setStartPosition();
    findEndPosition();
}

public ArrayList<Node> getPath() {

    Node node = endNode;

    while(node.hasParent()) {
        path.add(node);
        node = node.getParent();
    }

    return path;

}

public void findPath() {

    if(x!=endX || y!=endY) {
        getSurroundingNodes();
        if(options.size()>0) {
            Node lowestVal = options.get(0);
            for(Node i : options) {
                if(i.getValue()<lowestVal.getValue()) {
                    lowestVal = i;
                }
                else if(i.getValue() == lowestVal.getValue()) {
                    if(i.getEndDistance()<lowestVal.getEndDistance()) {
                        lowestVal = i;
                    }
                }
            }
            x = lowestVal.getX();
            y = lowestVal.getY();
            lowestVal.setTaken();
            options.remove(lowestVal);
            findPath();
        }
    }
    else {
        System.out.println("Made it");
    }

}

private void getSurroundingNodes() {

    Node parent = nodes[y][x];
    for(int i=y-1;i<y+2; i++) {
        for(int z=x-1;z<x+2; z++) {

            if(i>=0&&z>=0&&i<nodes.length&&z<nodes[i].length) {
                Node node = nodes[i][z];
                double endDistance = Math.sqrt((i-endY)*(i-endY)+(z-endX)*(z-endX));
                double startDistance = parent.getStartDistance()+Math.sqrt((i-y)*(i-y)+(z-x)*(z-x));
                double value = endDistance+startDistance;
                if(!node.isWall()&&!node.isTaken()) {
                    if(!options.contains(node)) {
                        node.setParent(parent);
                        node.setX(z);
                        node.setY(i);
                        node.setStartDistance(startDistance);
                        node.setEndDistance(endDistance);
                        node.setValue(value);
                        options.add(node);
                    }
                    else {
                        if(node.getValue()<value) {
                            //do nothing
                        }
                        else if (node.getValue() == value) {
                            if(node.getEndDistance()<=endDistance) {
                                //do nothing
                            }
                            else {
                                node.setParent(parent);
                                node.setX(z);
                                node.setY(i);
                                node.setStartDistance(startDistance);
                                node.setEndDistance(endDistance);
                                node.setValue(value);
                                options.add(node);
                            }
                        }
                        else {
                            node.setParent(parent);
                            node.setX(z);
                            node.setY(i);
                            node.setStartDistance(startDistance);
                            node.setEndDistance(endDistance);
                            node.setValue(value);
                            options.add(node);
                        }
                    }
                }
            }
        }
    }

}

private boolean findEndPosition() {

    for(Node[] i : nodes) {
        for(Node z : i) {
            if(z.isEnd()) {
                endX = z.getX();
                endY = z.getY();
                endNode = z;
                return true;
            }
        }
    }
    return false;       
}

private boolean setStartPosition() {

    for(Node[] i : nodes) {
        for(Node z : i) {
            if(z.isStart()) {
                z.setTaken();
                x = z.getX();
                y = z.getY();
                return true;
            }
        }
    }
    return false;       
}

Node:

private int x, y;
private boolean wall, start, end, taken, hasAParent;
private double endDistance, startDistance, value;
private Node parent = null;

public Node() {
    wall=false;
    start=false;
    end=false;
    taken=false;
    hasAParent = false;
}

public boolean hasParent() {
    return hasAParent;
}

public int getX() {
    return x;
}

public void setX(int x) {
    this.x = x;
}

public int getY() {
    return y;
}

public void setY(int y) {
    this.y = y;
}

public boolean isWall() {
    return wall;
}

public void setWall() {
    wall = true;
    end = false;
    start = false;
}

public boolean isStart() {
    return start;
}

public void setStart(int x, int y) {
    this.x = x;
    this.y = y;
    start = true;
    end = false;
    wall = false;
    endDistance=0.0;
    startDistance=0.0;
    value=0.0;
}

public boolean isEnd() {
    return end;
}

public void setEnd(int x, int y) {
    this.x = x;
    this.y = y;
    end = true;
    start = false;
    wall = false;
    hasAParent = true;
}

public boolean isTaken() {
    return taken;
}

public void setTaken() {
    taken = true;
}

public double getEndDistance() {
    return endDistance;
}

public void setEndDistance(double endDistance) {
    this.endDistance = endDistance;
}

public double getStartDistance() {
    return startDistance;
}

public void setStartDistance(double startDistance) {
    this.startDistance = startDistance;
}

public double getValue() {
    return value;
}

public void setValue(double value) {
    this.value = value;
}

public Node getParent() {
    return parent;
}

public void setParent(Node parent) {
    this.parent = parent;
    hasAParent = true;
}