Number of Occurrences of Each Different Word in a Line of Text

Both calls to replaceAll and the call to split could be replaced by 1 call to split. Remember that split accepts a regex and that regex patterns can endlessly combine matches for "one or more occurrences" of another pattern with matches for "one pattern or another", etc.

In any case, your regex usage would have to be a little more complicated if you wanted to support words like "don't".

Your counting algorithm does not scale up well for large inputs -- it's "O(n-squared)", and it uses a lot of custom code to make an ArrayList do the work of a more functional collection class. What you want is one scan over your tokens to build up a smarter collection of tokens with their running counts. For that, you want a collection that lets you efficiently find the running count for an "old" token without serially scanning for the token among all the tokens so far. After that, you can make one pass over the collection to print your output. That means that you want the collection to preserve the order in which you added each token.

There's a collection class for that. It's name currently escapes me. It'd probably be instructive for you to research it, anyway, since this is an educational project.

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;

public class TextAnalysisC {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    Scanner sc = new Scanner( System.in );
    System.out.println( "Please enter a line of text" );
    String userInput = sc.nextLine();

    userInput = userInput.toLowerCase();

    userInput = userInput.replaceAll( "\\W", " " );     // strip out any non words.
    userInput = userInput.replaceAll( "  ", " " );      // strip out any double spaces
                                                        //   created from stripping out non words
                                                        //   in the first place!
    String[] tokens = userInput.split( " " );

    ArrayList< String > items = new ArrayList< String >();

    items.addAll( Arrays.asList( tokens ) );

    int count = 0;

    for( int i = 0; i < items.size(); i++ )
    {
        if( items.get( i ).equals( "***" ) )    // skip words marked as duplicate
            continue;                           //   not essential, only in the interests 
                                                //   of reducing clock cycles
        for( int j = 0; j < items.size(); j++ )
        {
            if( items.get( i ).equals( items.get( j ) ) )
                count++;
            if( items.get( i ).equals( items.get( j ) ) && count > 1 )
            {
                items.remove( j );
                items.add( j, "***" );                   
            }
        }                                                     
        count = 0;
    }

    for( int i = 0; i < items.size(); i++ )     // time to strip out "***"
        if( items.get( i ).equals( "***" ) )
            items.remove( i-- );            // remove then post decrement i
                                            //   due to shifting ArrayList indexes

    int[] countArray = new int[ items.size() ];

    for( int i = 0; i < items.size(); i++ )     // count frequency of words into countArray
        for( int j = 0; j < tokens.length; j++ )
            if( items.get( i ).equals( tokens[ j ]) )
                countArray[ i ]++;

    System.out.println();

    for( int i = 0; i < items.size(); i++ )     // print results into crude table
        System.out.printf( "%s: %d\n", items.get( i ), countArray[ i ] );
}
}

OK so this is the solution I came up with after a second look. It seems to work without breaking. I'm not so sure if it is good practice to mess with a for loop variable within the scope of said for loop? I did it anyway at the point where I was stripping out markers (see comments, post decrement) and it seems to work a treat. This was needed due to the shifting ArrayList indexes that occur when an item is removed from the list.