WordSearch Solver Algorithm Help

Question

Hello, I am making a WordSearch solver. I have an algorithm, and I have it in code, but I can't figure out why it isn't working.
Basically, I have a `List<List<String>>` that contains the WordSearch. I store that in a class called Grid, and in my Finder method use Grid.look() to find the words. The code is below (sorry for not commenting my code), and I would appreciate it if someone could tell me what is going wrong. The first Point (where each correct letter is) is always right, but none of the other ones are.
Direction.java
package com.wordsearchsolver;
import java.awt.Point;
public final class Direction {
     public static Directions NORTH = Directions.NORTH;
     public static Directions NORTHEAST = Directions.NORTHEAST;
     public static Directions EAST = Directions.EAST;
     public static Directions SOUTHEAST = Directions.SOUTHEAST;
     public static Directions SOUTH = Directions.SOUTH;
     public static Directions SOUTHWEST = Directions.SOUTHWEST;
     public static Directions WEST = Directions.WEST;
     public static Directions NORTHWEST = Directions.NORTHWEST;
     private static enum Directions {
          NORTH, NORTHEAST, EAST, SOUTHEAST,
          SOUTH, SOUTHWEST, WEST, NORTHWEST
     public static Point getDirection(Directions d) {
          Point p = new Point();
          switch (d) {
          case NORTH:
               p.setLocation(0, 1);
               break;
          case NORTHEAST:
               p.setLocation(1, 1);
               break;
          case EAST:
               p.setLocation(1, 0);
               break;
          case SOUTHEAST:
               p.setLocation(1, -1);
               break;
          case SOUTH:
               p.setLocation(0, -1);
               break;
          case SOUTHWEST:
               p.setLocation(-1, -1);
               break;
          case WEST:
               p.setLocation(-1, 0);
               break;
          case NORTHWEST:
               p.setLocation(-1, 1);
               break;
          return p;
}Grid.java
package com.wordsearchsolver;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Grid {
     private List<List<String>> mapByCollumn;
     private Point index;
     public Grid(List<List<String>> mapByCollumn) {
          this.mapByCollumn = mapByCollumn;
          this.index = new Point(0,0);
     public String traverse(Point p) {
          if ((index.x+p.x) >= 0 && (index.y+p.y) >= 0 && (index.y+p.y) < mapByCollumn.size() && (index.x+p.x) < mapByCollumn.get((index.y+p.y)).size())
               index.setLocation(index.x+p.x, index.y+p.y);
          else return "";
          return mapByCollumn.get(index.y).get(index.x);
     public String look(Point p) {
          if ((index.x+p.x) >= 0 && (index.y+p.y) >= 0 && (index.y+p.y) < mapByCollumn.size() && (index.x+p.x) < mapByCollumn.get((index.y+p.y)).size())
               return mapByCollumn.get(index.y+p.y).get(index.x+p.x);
          return "";
     public List<Point> getStartingPoints(String letter) {
          Iterator<List<String>> mapIterator = mapByCollumn.iterator();
          List<Point> startingPoints = new ArrayList<Point>();
          int mapCount      = 0;
          while (mapIterator.hasNext()) {
               Iterator<String> wordIterator = mapIterator.next().iterator();
               int wordCount      = 0;
               while (wordIterator.hasNext()) {
                    String str = wordIterator.next();
                    if (str.equals(letter))
                         startingPoints.add(new Point(mapCount, wordCount));
                    wordCount++;
               mapCount++;
          return startingPoints;
     public Point getIndex() {
          return index;
     public void setIndex(Point p) {
          index.setLocation(p);
}Finder.java
package com.wordsearchsolver;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Finder {
     private Grid grid;
     private List<Point> answerList;
     private List<List<String>> mapByCollumn;
     private Point direction;
     protected String word = "";
     public Finder(List<List<String>> mapByCollumn) {
          this.mapByCollumn     = mapByCollumn;
          grid                     = new Grid(mapByCollumn);
          answerList               = new ArrayList<Point>();
     public void find() {
          List<Point> startingPoints = grid.getStartingPoints(""+word.charAt(0));
          Iterator<Point> startingIterator = startingPoints.iterator();
          System.out.println(startingPoints);
          while (startingIterator.hasNext()) {
               Point p = startingIterator.next();
               grid.setIndex(p);
               boolean go = false;
               for (int i = 1; i < word.length(); ++i) {
                    if (!go) {
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.NORTH)))) {
                         grid.traverse(Direction.getDirection(Direction.NORTH));
                         answerList.add(grid.getIndex());
                         direction = Direction.getDirection(Direction.NORTH);
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.NORTHEAST)))) {
                         grid.traverse(Direction.getDirection(Direction.NORTHEAST));
                         answerList.add(grid.getIndex());
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.EAST)))) {
                         grid.traverse(Direction.getDirection(Direction.EAST));
                         answerList.add(grid.getIndex());
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.SOUTHEAST)))) {
                         grid.traverse(Direction.getDirection(Direction.SOUTHEAST));
                         answerList.add(grid.getIndex());
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.SOUTH)))) {
                         grid.traverse(Direction.getDirection(Direction.SOUTH));
                         answerList.add(grid.getIndex());
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.SOUTHWEST)))) {
                         grid.traverse(Direction.getDirection(Direction.SOUTHWEST));
                         answerList.add(grid.getIndex());
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.WEST)))) {
                         grid.traverse(Direction.getDirection(Direction.WEST));
                         answerList.add(grid.getIndex());
                         continue;
                    if ((word.charAt(i)+"").equals(grid.look(Direction.getDirection(Direction.NORTHWEST)))) {
                         grid.traverse(Direction.getDirection(Direction.NORTHWEST));
                         answerList.add(grid.getIndex());
                         continue;
                    else if (go) {
                         if ((word.charAt(i)+"").equals(grid.look(direction))) {
                              grid.traverse(direction);
                              answerList.add(grid.getIndex());
                              continue;
                    answerList.clear();
                    go = false;
                    break;
               if (!answerList.isEmpty()) {
                    answerList.add(0, p);
                    break;
     public List<Point> getAnswerList() {
          return answerList;
}

Answer 1

First, that's way too much code. You should be writing and testing individual small pieces independently, and then hooking them together once they work. It's much easier to find a problem in a small bit of code than in a lot of code. Narrow down where the problem is occurring and provide an [url http://sscce.org]SSCCE that demonstrates it.
Second, all you've said is "doesn't work." You need to provide details about exactly what is going wrong.