Scrabble algorithm review and performance suggestions

@Teresa has already provided some good hints on how to improve the performance by using a better data structure so I'll concentrate on general things:

1. Your code has a bug such as that it will crash with a NullPointerException if the file cannot be found.

   • You initialize dict to null
   • You catch the FileNotFoundException when trying to create dict
   • If the exception got caught the dict will still be null and it will throw when you try to access it.

   So the whole try-catch around the Scanner instantiation is pretty much useless as it will crash anyway. Even worse: Instead of getting a FileNotFoundException which pretty much tells you what is wrong you get a fairly meaningless NullPointerException.

2. You have two static arrays numbers and numbers2. These names are useless as they do in no way give you any idea whatsoever what they are being used for. The name of a variable, method, class, parameter, etc. is effectively the advertising sign for its purpose. A good concise name goes a long way of

   • Making your code more readable and understandable
   • Reducing bugs by misunderstanding the purpose of your own variables

   In this case there is not much code and it's not terribly complicated but you should get into the habit of choosing good names.

3. dict is not a good name for the Scanner as it doesn't represent a dictionary in itself - it's a reader which reads lines from a file.

4. All your code is in the main method. You should get into the habit of building reusable pieces of code - in the case of Java this means creating reusable classes. So I'd suggest your create a dedicated class which holds your lookup structure and provide as well defined interface for adding valid words and looking up a word. Something like this:

   public class WordLookup
   {
       public WordLookup()
       {
           ...
       }
   
       public void addValidWord(string word)
       {
           ...
       }
   
       public bool isValidWord(string word)
       {
           ...
       }
   }
   

   Now main can be rewritten as:

   public static void main(String[] args) {
       Scanner reader = new Scanner(new File("words.txt"));
   
       WordLookup lookup = new WordLookup();
   
       while (reader.hasNextLine()) {
           lookup.addValidWord(reader.nextLine());
       }
   
       String n = "gojy";//random text here
   
       rearrange("", n);
       LinkedHashSet<String> listToSet = new LinkedHashSet<String>(numbers2);
       ArrayList<String> listWithoutDuplicates = new ArrayList<String>(listToSet);
       for (int i = 0; i < listWithoutDuplicates.size(); i++) {
           string currentWord = listWithoutDuplicates.get(i);
           if (lookup.isValidWord(currentWord)) {
               System.out.println(currentWord);
           }
       }
   }
   

   What do you gain from it: You can now fiddle with the implementation of WordLookup without having to touch the main method.

I came across a saying a while ago, don't remember where, which I quite like:

Train like you fight because you will fight like you train

So train yourself to write well structured encapsulated code even for seemingly simple things because it will form a habit. Even if you don't want to develop software professionally in the long run you will find it more rewarding when you do it right.

I found the code rather hard to follow due to some unconventional naming:

• numbers and numbers2 are actually lists of Strings, not numbers.
• dict is a Scanner, not a dictionary.
• n is a String, not an integer.

The numbers2 assignment has inexplicable trailing braces. That creates an anonymous inner class that extends ArrayList, but not overriding or defining any additional members!

You swallowed FileNotFoundException, which just makes debugging more difficult. In general, if you don't know what to do about an exception, just let it propagate. In this case,

public static void main(String[] args) throws FileNotFoundException

will take care of it.

To iterate through all elements of a list…

for (String s : listWithoutDuplicates) {
    …
}