spell checker

import java.util.*;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class Main
{

    // Return a scanner for the given file with the given name.
    private static Scanner openFileWithScanner(String fileName)
    {
        Scanner scanner;
        try
        {
            scanner = new Scanner(new BufferedReader(new FileReader(fileName)));
        }
        catch (FileNotFoundException ex)
        {
            System.err.println("Unable to open " + fileName);
            System.exit(1);
            return null;
        }
        return scanner;
    }

   public static void main(String[] args)
   {
        // Open a scanner for the dictionary
        if(args.length < 1)
        {
            System.err.println("No dictionary file name given.");
        }
        final Scanner dictionaryScanner = openFileWithScanner(args[0]);

        // Get the scanner for the input
        final Scanner inputScanner;
        if(args.length < 2)
        {
            inputScanner = new Scanner(new BufferedInputStream(System.in));
        }
        else
        {
            inputScanner = openFileWithScanner(args[1]);
        }

        /* Add your code here */
       Map<String,Integer> dictionaryMap = new HashMap<>();
       while(dictionaryScanner.hasNextLine()){
           String s = dictionaryScanner.nextLine();
           dictionaryMap.put(s,s.length());
       }

       HashMap<Integer,String> inputMap = new HashMap<Integer, String>();
       LinkedList<String> result = new LinkedList<String>();
       int index = 0;
       while(inputScanner.hasNext()){
           inputMap.put(index,inputScanner.next());
           index++;
       }
       for(int j = 0;j<index;j++){
            String unCheckValue = inputMap.get(j);
            if(!dictionaryMap.containsKey(unCheckValue)){
                //deal the string
                LinkedList<String> resultOfValue = new LinkedList<String>();
                if(dictionaryMap.values().contains(unCheckValue.length() + 1) ){
                    resultOfValue.addAll(insertAnyChar(unCheckValue,dictionaryMap));
                }
                if (dictionaryMap.values().contains(unCheckValue.length()) ) {
                    resultOfValue.addAll(changeAnyChar(unCheckValue,dictionaryMap));
                    resultOfValue.addAll(exchangeAnyChar(unCheckValue,dictionaryMap));
                }
                if(dictionaryMap.values().contains(unCheckValue.length() - 1) ) {
                    resultOfValue.addAll(removeAnyChar(unCheckValue,dictionaryMap));
                }

                if(resultOfValue.size() == 0){
                    result.add(unCheckValue + " : *no alternates found*");
                }else {
                    Collections.sort(resultOfValue);
                    StringBuilder stringBuilder = new StringBuilder(unCheckValue + " : ");
                    for(String ss : resultOfValue){
                        stringBuilder.append(ss + ", ");
                    }
                    result.add(stringBuilder.substring(0,stringBuilder.length()-2));
                }
            }
       }
       result.stream().forEach(e -> System.out.println(e));


   }

    private static LinkedList<String> changeAnyChar(String unCheckVal, Map<String, Integer> dictionaryMap) {
        LinkedList<String> changeResult = new LinkedList<String>();
        StringBuilder stringBuilder = new StringBuilder(unCheckVal);
        for(int index = 0 ;index<stringBuilder.length();index++){
            for(int j = 0 ;j<26;j++) {
                stringBuilder.setCharAt(index, (char) (j + 97));
                String changeValue = stringBuilder.toString();
                if (dictionaryMap.containsKey(changeValue)) {
                    changeResult.add(changeValue);
                }
                stringBuilder = new StringBuilder(unCheckVal);
                stringBuilder.setCharAt(index, (char) (j + 65));
                changeValue = stringBuilder.toString();
                if (dictionaryMap.containsKey(changeValue)) {
                    changeResult.add(changeValue);
                }
                stringBuilder = new StringBuilder(unCheckVal);
            }
        }
        return changeResult;
    }

    private static LinkedList<String> removeAnyChar(String unCheckVal, Map<String, Integer> dictionaryMap) {
        LinkedList<String> removeResult = new LinkedList<String>();
        StringBuilder stringBuilder = new StringBuilder(unCheckVal);
        for(int index = 0 ;index<stringBuilder.length();index++){
            String removeValue = stringBuilder.deleteCharAt(index).toString();
            if(dictionaryMap.containsKey(removeValue)){
                removeResult.add(removeValue);
            }
            stringBuilder = new StringBuilder(unCheckVal);
        }
        return removeResult;
    }

    private static LinkedList<String> exchangeAnyChar(String unCheckVal, Map<String, Integer> dictionaryMap) {
        LinkedList<String> exchangeResult = new LinkedList<String>();
        StringBuilder stringBuilder = new StringBuilder(unCheckVal);
        for(int index = 0 ;index<stringBuilder.length()-1;index++){
            char temp = stringBuilder.charAt(index);
            stringBuilder.setCharAt(index,stringBuilder.charAt(index+1));
            stringBuilder.setCharAt(index+1,temp);
            String exchangeValue = stringBuilder.toString();
            if(dictionaryMap.containsKey(exchangeValue)){
                exchangeResult.add(exchangeValue);
            }
            stringBuilder = new StringBuilder(unCheckVal);
        }
        return exchangeResult;
    }

    /* Add Methods as needed */
   private HashMap<Integer, String> readIntoMap(Scanner inputScanner,int size)
   {
       HashMap<Integer,String> result = new HashMap<Integer, String>();
       for(int index = 0;index<size;index++){
           result.put(index,inputScanner.next());
       }

       return result;
   }

   static LinkedList<String> insertAnyChar(String uncheckVal, Map<String, Integer> dictionaryMap){
       LinkedList<String> insertResult = new LinkedList<String>();
       StringBuilder stringBuilder = new StringBuilder(uncheckVal);
       for(int index = 0 ;index <= stringBuilder.length();index++){
           for(int j = 0 ;j<26;j++) {
               String insertValue = stringBuilder.insert(index, (char) (65 + j)).toString();
               if (dictionaryMap.containsKey(insertValue)) {
                   insertResult.add(insertValue);
               }
               stringBuilder = new StringBuilder(uncheckVal);
               insertValue = stringBuilder.insert(index, (char) (97 + j)).toString();
               if (dictionaryMap.containsKey(insertValue)) {
                   insertResult.add(insertValue);
               }
               stringBuilder = new StringBuilder(uncheckVal);
           }
       }
       return insertResult;

   }
}