Robot will not return to previous spots it's been

I am making a robot that fins a flasher in a maze and brings it back to its original position. When I test my code, the robot will find the flasher, but then get stuck and not return to it's starting position. I've written other methods to make the program easier, they include methods that check if the next intersection has been visited by the robot, another method that calculates the next avenue and street, and one that turns the robot is a specified direction. Here is the full code:

import becker.robots.Robot;
import becker.robots.City;
import becker.robots.Direction;
import becker.robots.Intersection;
import java.util.ArrayList;

/* This program has a robot search a maze for a flasher, picks the flasher up, and
returns back to it's starting position. If no flasher is f开发者_运维知识库ound, it will return back 
to the starting position as well.
*/

public class RobotUtils{
    Robot meow;
    /* This method says what avenue the robot will be on if it decides to move
    one intersection in the direction it's facing
    */
    public static int calculateNextAvenue(Robot meow){
        int avenue = meow.getAvenue();
        Direction direction = meow.getDirection();
        //Changes the value of the avenue the robot is on when facing west
        if (direction == Direction.WEST){
            return avenue - 1;
        }
        //Changes the value of the avenue the robot is on when facing east
        if (direction == Direction.EAST){
            return avenue + 1;
        }
        //If facing north or south, doesn't change the value
        else{
            return avenue;
        }
    }
    /* This method says what street the robot will be on if it decides to move
    one intersection in the direction it's facing
    */
    public static int calculateNextStreet(Robot meow){
        int street = meow.getStreet();
        Direction direction = meow.getDirection();
        //Changes the value of the avenue the robot is on when facing south
        if (direction == Direction.SOUTH){
            street = street + 1;
        }
        //Changes the value of the avenue the robot is on when facing north
        if (direction == Direction.NORTH){
            street = street - 1;
        }
        //If facing east or west, doesn't change the value
        return street;
    }
    //This method turns the robot to face a certain specified direction
    public static void turnRobot(Robot meow, Direction face){
        Direction direction = meow.getDirection();
        while (direction != face){
            meow.turnLeft();
            direction = meow.getDirection();
        }
    }
    //This method checks a list to see if a certain intersection is in the list
    public static boolean isVisited(ArrayList<Intersection> search , int
        street, int avenue){
        Intersection inter;
        boolean found = false;
        int i = 0;
        while (found == false && i < search.size()){
            inter = search.get(i);
            if (inter.getAvenue()== avenue && 
                inter.getStreet() == street){
                found = true;
            }
            i++;
        }
        return found;
    }
    //This method makes the robot search a maze, find a flasher if there is
    //one, pick the flasher up, and return back to its starting position.
    public static void retrieveLight(Robot meow){
        ArrayList<Direction> path;
        path = new ArrayList<Direction>();
        ArrayList<Intersection> intersections;
        intersections = new ArrayList<Intersection>();
        boolean searched = false;
        boolean flasher = false;
        int street = meow.getStreet();
        int avenue = meow.getAvenue();
        Intersection current = meow.getIntersection();

        //Adds the current intersection the robot is on to a list that
        //keeps track of where the robot has been
        while (searched == false  && flasher == false){
            Direction d = meow.getDirection();
            if (isVisited(intersections, street, avenue) == false){
                intersections.add(current);
            }
            //Robot picks flasher up
            if (meow.canPickThing()){
                flasher = true;
                meow.pickThing();
            }
            //Makes the robot move towards intersections it hasn't visited yet
            //to search the maze to find the flasher
            else {
    //Robot moves if an adjacent intersection hasn't been visited yet
    if (!isVisited(intersections, calculateNextStreet(meow),
    calculateNextAvenue(meow)) && meow.frontIsClear()){
            path.add(d);
            turnRobot(meow, d);
            meow.move();            
    }           
    //If path is blocked or intersection has been visited, 
    //robot turns to look for new direction to move in
        if (isVisited(intersections,  calculateNextStreet(meow),
        calculateNextAvenue(meow)) || !meow.frontIsClear()){
                        meow.turnLeft();
                    }
    //If the robot has searched the entire maze without
    //finding flasher, exits the loop
        else if (path.isEmpty()){
        searched = true;
    }
    //If all intersections around robot have been visited/are blocked,
    //robot back tracks to find a new intersection to visit
        else {
        int last = path.lastIndexOf(d);
        path.remove(last);
        turnRobot(meow, d.opposite());
        meow.move();
            }           
            }
        }
        //Have robot go back to start by backtracking all intersections it
        //has visited
            int i = path.size();
            while (i >= 0 && isVisited(intersections, 
            calculateNextStreet(meow),calculateNextAvenue(meow))){
                Direction d = meow.getDirection();
                int last = path.lastIndexOf(d);
                path.remove(last);
                turnRobot(meow, d.opposite());
                meow.move();
                i--;
                } 
    }
}

I think the main problem with the code is in this section:

//Makes the robot move towards intersections it hasn't visited
//to search the maze to find the flasher
else {
//Robot moves if an adjacent intersection hasn't been visited yet
if (!isVisited(intersections, calculateNextStreet(meow),
  calculateNextAvenue(meow)) && meow.frontIsClear()){
    path.add(d);
    turnRobot(meow, d);
    meow.move();            
}           
//If path is blocked or intersection has been visited, 
//robot turns to look for new direction to move in
    if (isVisited(intersections, calculateNextStreet(meow),
     calculateNextAvenue(meow)) || !meow.frontIsClear()){
        meow.turnLeft();
    }
//If the robot has searched the entire maze without
//finding flasher, exits the loop
    else if (path.isEmpty()){
        searched = true
        }
//If all intersections around robot have been visited/are blocked,
//robot back tracks to find a new intersection to visit
    else {
    int last = path.lastIndexOf(d);
    path.remove(last);
    turnRobot(meow, d.opposite());
    meow.move();
    }           
                }
            }
//Have robot go back to start by backtracking all intersections it
//has visited
                int i = path.size();
                while (i >= 0 && isVisited(intersections, 
                calculateNextStreet(meow),calculateNextAvenue(meow))){
                    Direction d = meow.getDirection();
                    int last = path.lastIndexOf(d);
                    path.remove(last);
                    turnRobot(meow, d.opposite());
                    meow.move();
                    i--;
                    } 
        }
    }

If you could help me I would greatly appreciate it.

EDIT My robot keeps crashing now into the wall once it's found the flasher, any thoughts? How should I terminate the last while loop?

---

You should create a Stack of all the points you traversed in the maze, then once you reach your destination, "pop" each point out of the Stack. That will effectively let you retrace your steps and is very easy to code into your current code. It's much easier than using an ArrayList...