程序由于未知原因引发java.lang.StringIndexOutOfBounds异常

Question

I'm now having a problem when running my HashMap program. It compiles, but running it throws a java.util.StringIndexOutOfBoundsException related to my use of charAt on line 45:

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import java.util.Set;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import javax.swing.JFileChooser;
import java.util.ArrayList;

//* This program inputs a text file, process it, and maps each word to a   hash map. At the end it outputs a list of all */
/* words in the file that are unique (occuring only once) and also the top five most commonly used words */


public class HashMapLab
{
  public static void main(String[] args) throws FileNotFoundException
{
//creates and initualizes a hash map
HashMap<String, Integer> words = new HashMap<String, Integer>();

//allows user to select the file and inputs it word by word
JFileChooser chooser = new JFileChooser();
Scanner in = null;
if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION)
{
  File selectedFile = chooser.getSelectedFile();
  in = new Scanner(selectedFile);

  //This lengthy loop processes each word, character by character
  while (in.hasNext())
  {
    //The next word in the selected file is input and turned into a string
    String input = in.next();
    //And this scanner breaks the word up character by character
    Scanner characterizer = new Scanner(input);
    characterizer.useDelimiter("");
    int counter = 0;

    ArrayList<Character> placeHolder = new ArrayList<Character>();

    while (counter < input.length())
    {
      //This is the reason why. Each character is checked against a blacklist. Forbidden characters are discarded.
      char character = characterizer.next().charAt(counter);
      if (character != '(' && character != ')' && character != '.' && character != '-' && character != '$' 
         && character != '?' & character != '!' && character != ';' && character != ':' && character != '"' &&
         character != '&' && character != '#' && character != '*')
      {
        placeHolder.add(character);
      }
      counter++;
    }

    /*After adding all permitted characters to an arraylist of variable size, that array list is converted
     * here to a fixed length array. */
    final int LENGTH = placeHolder.size();
    char[] word = new char[LENGTH];

    int currentSize = 0;
    if (currentSize < word.length)
    {
      currentSize++;
      word[currentSize] = placeHolder.get(currentSize);
    }

    //Because it is an array, it can be simply converted into a string, now devoid of blacklisted characters.
    String finalWord = new String(word);

    /* This is what all that code was leading up to. finalWord should be a permissible word by now, contaning
     * no blacklisted characters. This loop checks to see if finalWord is in the hashmap yet. If it is
     * then the value of that word is incrimented. If not, it is added to the hashmap. This should allow
     * the entire document to be processed, producing a hashmap that contains each unique word in the document
     * along with the number of times that word is present. */
    if (words.containsKey(finalWord))
    {
      Integer I = words.get(finalWord);
      words.put(finalWord, I++);
    }
    else
    {
      words.put(finalWord, 1);
    }
  }
}

} }se help!

Answer 1

for an unknown reason - the reason is actually given to you pretty clearly:

StringIndexOutOfBoundsException: String index out of range: -1 at java.lang.String.charAt(Unknown Source)

At some point of time a "string index" is -1, which is "out of range". The only place that uses a "index" of a string, is this piece:

characterizer.next().charAt(counter);

And a proper "range" for the string index is usually from 0 to string.length()-1 .

Therefore, from the given error, you can guess that for some reason, as @Kayaman noticed, counter variable is -1 .

---

Edited because of change in question:

The code characterizer.next().charAt(counter); in your case increments the counter, and then tries to get the character from it's position from every matching string, which is of length 1 every time.

To reword that, characterizer.next() - returns a 1 character string each time, counter is incremented in sequence from 0 to length-1 , but characterizer.next().charAt(counter) , can't work because each matched string is of size 1 always.

You could either remove the characterizer at all, and leave it at input.charAt(counter) , or change charAt(counter) to charAt(0) .