Java read string word by word

Are you completely sure you need to consider that's as two words? (viz. that is)

Ordinarily, I believe that's is counted as one word in English.

But if your perspective on the requirements is correct, you have a (moderately) difficult problem: I don’t think there is any (reasonable) regex that can distinguish between something like that's (contraction of that and is) and something like steve's (possessive).

AFAIK you will have to write something yourself.

Suggestion: take a look at this list of English language contractions. You could use it to make an enumeration of the things you need to handle in a special way.

Basic Example

enum Contraction {
    AINT("ain't", "is not"),
    ARENT("aren't", "are not"),
    // Many, many in between...
    YOUVE("you've", "you have");

    private final String oneWord;
    private final String twoWords;

    private Contraction(String oneWord, String twoWords) {
        this.oneWord = oneWord;
        this.twoWords = twoWords;
    }

    public String getOneWord() {
        return oneWord;
    }

    public String getTwoWords() {
        return twoWords;
    }
}

String s = "That's a good question".toLowerCase();
for (Contraction c : Contraction.values()) {
    s = s.replaceAll(c.getOneWord(), c.getTwoWords())
}
String[] words = s.split("\s+");
// And so forth...

NOTE: This example handles case sensitivity by converting the entire input to lower case, so the elements in the enum will match. If that doesn’t work for you, you may need to handle it in another way.

I’m not clear on what you need to do with the words once you have them, so I left that part out.

I need to write a program that rads the text of a text file and returns the amount of times a specific word shows up. I cant figure out how to write a program that reads the text file word by word, ive only managed to write a file that reads line by line. How would i make it so it reads word by word?

import java.io.*;
import java.util.Scanner;


public class main 
{
	public static void main (String [] args) 
	{		
		Scanner scan = new Scanner(System.in);
		System.out.println("Name of file: ");		
		String filename= scan.nextLine();
	int count =0; 

	try
	{		
		FileReader file = new FileReader(filename);			
		BufferedReader reader = new BufferedReader(file);			
		String a = "";			
		int linecount = 0;						
		String line;			
		System.out.println("What word are you looking for: ");			
		String a1 = scan.nextLine();						
	
		while((line = reader.readLine()) != null)			
		{				
			linecount++;								
			if(line.equalsIgnoreCase("that"));
					count++;			
		}								
		reader.close();		
	}
	catch(IOException e)
	{
		System.out.println("File Not found");
	}
	System.out.println("the word that appears " + count + " many times");
}
}

There are various methods in Java using which you can parse for words in a string for a specific word. Here we are going to discuss 3 of them.

The contains() method

The contains() method of the String class accepts a sequence of characters value and verifies whether it exists in the current String. If found it returns true else, it returns false.

Example

 Live Demo

import java.util.StringTokenizer;
import java.util.regex.Pattern;
public class ParsingForSpecificWord {
   public static void main(String args[]) {
      String str1 = "Hello how are you, welcome to Tutorialspoint";
      String str2 = "Tutorialspoint";
      if (str1.contains(str2)){
         System.out.println("Search successful");
      } else {
         System.out.println("Search not successful");
      }
   }
}

Output

Search successful

The indexOf() method

The indexOf() method of the String class accepts a string value and finds the (starting) index of it in the current String and returns it. This method returns -1 if it doesn’t find the given string in the current one.

Example

 Live Demo

public class ParsingForSpecificWord {
   public static void main(String args[]) {
      String str1 = "Hello how are you, welcome to Tutorialspoint";
      String str2 = "Tutorialspoint";
      int index = str1.indexOf(str2);
      if (index>0){
         System.out.println("Search successful");
         System.out.println("Index of the word is: "+index);
      } else {
         System.out.println("Search not successful");
      }
   }
}

Output

Search successful
Index of the word is: 30

The StringTokenizer class

Using the StringTokenizer class, you can divide a String into smaller tokens based on a delimiter and traverse through them. Following example tokenizes all the words in the source string and compares each word of it with the given word using the equals() method.

Example

 Live Demo

import java.util.StringTokenizer;
public class ParsingForSpecificWord {
   public static void main(String args[]) {
      String str1 = "Hello how are you welcome to Tutorialspoint";
      String str2 = "Tutorialspoint";
      //Instantiating the StringTookenizer class
      StringTokenizer tokenizer = new StringTokenizer(str1," ");
      int flag = 0;
      while (tokenizer.hasMoreElements()) {
         String token = tokenizer.nextToken();
         if (token.equals(str2)){
            flag = 1;
         } else {
            flag = 0;
         }
      }
      if(flag==1)
         System.out.println("Search successful");
      else
         System.out.println("Search not successful");
   }
}

Output

Search successful

Using a Stack and StringTokenizer seems to be a bit of an overkill here. A more simplified version could be written like this:

public static String reverse(final String input) {
  Objects.requireNonNull(input);
  final StringBuilder stringBuilder = new StringBuilder();
  for (final String part : input.split("\s+")) {
    if (!part.isEmpty()) {
      if (stringBuilder.length() > 0) {
        stringBuilder.insert(0, " ");
      }
      stringBuilder.insert(0, part);
    }
  }
  return stringBuilder.toString();
}

This uses the ability of split() to take a String apart based on a given Regex. So the string is split based on a sequence of one or more white-spaces, which matches your initial requirement. Note that split will return an empty array in case input is an empty string.

The for-each loop then works through the array and inserts the part at the beginning of the stringBuilder (except for the first time), which will effectively reverse the array. Most people would probably use a reverse for(i...) loop here, but because this is a code review I try to be extra correct, and this is the safer version: You cannot cause ArrayIndexOutOfBoundsExceptions with for-each.

Any leading/trailing white-space will cause empty parts to appear in the splitted list, so there is a check for it in the loop. I use isEmpty() here, as this is in general safer (as in: less chance to do typos) than length() > 0 and benefits from potential, internal optimizations of String in terms of execution speed. You could call trim() beforehand, but this would cause some unnecessary String operations and creations, so this version is more efficient.

Please also note the check for null at the beginning. The code would otherwise throw when trying to split on null, but it is considered good practice to check before-hand, as theoretically (not in this code but in other) you otherwise might leave the system in an undefined state.

I also make use of final, which allows some compiler optimizations and prevents you from some basic coding mistakes, which is considered good practice.

Testing

It is always a good idea to do some quick testing of the functionality including the basic edge-cases, so here it is:

To check whether or not I do correct white-space removal, I change stringBuilder.insert(0, " ") to stringBuilder.insert(0, "+") for the test, to make the white-space visible.

When testing with System.out.println(reverse("the sky is blue")); the result is:
blue+is+sky+the The initial requirement is met.

When testing with System.out.println(reverse(" t the sky ist blue ")); the result is:
blue+is+sky+the Leading, trailing and in-between white-spaces are correctly removed.

When testing with reverse("") the result is an empty String as expected.

When testing with reverse(null) a NullPointerException is thrown at the beginning of the function.