Does a string consist of a single keyword, or perhaps you want to compare sentences and see how many words they have in common?  

I would like to compare sentences and then see how many words they have in common.

1. String s0, s1;
2. 
   
3. public void setup() {
4.   s0 = "Mary had a little lamb its fleece as white as snow";
5.   s1 = "Snow White lived with seven dwarves";
6.   compareSentences(s0, s1);
7. }
8. 
   
9. public void compareSentences(String st0, String st1) {
10.   int m = 0;
11.   float f = 0;
12.   // Create a array of words (lowercase) and sort them
13.   // in alphabetical order
14.   String[] w0 = split(st0, ' ');
15.   for (int i = 0; i < w0.length; i++)
16.     w0[i] = w0[i].toLowerCase();
17.   w0 = sort(w0);
18.   // Same for the second sentence
19.   String[] w1 = split(st1, ' ');
20.   for (int i = 0; i < w1.length; i++)
21.     w1[i] = w1[i].toLowerCase();
22.   w1 = sort(w1);
23.   int p0 = 0, p1 = 0;
24.   do {
25.     int comp = w0[p0].compareTo(w1[p1]);
26.     // println(w0[p0] + "  " + w1[p1] + "  " + comp);
27.     if (comp == 0) { // same word
28.       m++;
29.       p0++;
30.       p1++;
31.     }
32.     else if (comp < 0) { // w0 word is before w1 word
33.       p0++;
34.     }
35.     else if (comp > 0) { // w0 word is after w1 word
36.       p1++;
37.     }
38.   }
39.   while (p0 < w0.length && p1 < w1.length);
40.   f = (2.0f * m) / ( w0.length + w1.length );
41.   println("Found " + m + " matching words");
42.   println("Simularity factor: " + f);
43. }

void setup() {
    String x = "one two three four";
    String y = "three four five six";
    print(common_words(x, y));
}

// Returns the number of words in common between x and y.
// Letter case doesn't matter. Non-alphabetic characters are ignored.
int common_words(String x, String y) {
    String[] xwords = x.toLowerCase().split("[^a-z]+");
    String[] ywords = y.toLowerCase().split("[^a-z]+");
    Set<String> xset = new HashSet<String>(Arrays.asList(xwords));
    Set<String> yset = new HashSet<String>(Arrays.asList(ywords));
    xset.retainAll(yset);
    println("The common words are: " + xset);
    return xset.size();
}

// Outputs:
// The common words are: [three, four]
// 2

/** 
 * Common Words (v2.11)
 * by  Harry (2013/Sep)
 * mod GoToLoop
 * 
 * http://forum.processing.org/topic/
 * how-can-i-calculate-similarity-score-of-strings
 */

import java.util.Collection;
import java.util.HashSet;
import java.util.Arrays;

void setup() {
  final String x = " one two three four";
  final String y = "five four,   six three ";

  final Collection common = commonWords(x, y);

  println("Common words: " + common);
  println("Quantity: #" + common.size());

  exit();
}

static final Collection<String> commonWords(String x, String y) {
  final String[] xWords = x.toLowerCase().split("[^a-z]+");
  final String[] yWords = y.toLowerCase().split("[^a-z]+");

  final Collection<String> xSet = new HashSet(Arrays.asList(xWords));
  xSet.retainAll( new HashSet(Arrays.asList(yWords)) );

  return xSet;
}

Your Collection return type should have a generic type as well.

/** 
 * Common Words (v3.21)
 * by  Harry (2013/Sep)
 * mod GoToLoop
 * 
 * http://forum.processing.org/topic/
 * how-can-i-calculate-similarity-score-of-strings
 */

import java.util.HashSet;
import java.util.Arrays;

void setup() {
  final String x = " one two three four";
  final String y = "five four,   six three ";

  final String[] common = commonWords(x, y);

  println("Common words: ");
  println(common);
  println("\nQuantity: #" + common.length);

  exit();
}

static final String[] commonWords(String x, String y) {
  final String[] xWords = x.toLowerCase().split("[^a-z]+");
  final String[] yWords = y.toLowerCase().split("[^a-z]+");

  final HashSet<String> xSet = new HashSet(Arrays.asList(xWords));
  xSet.retainAll( new HashSet(Arrays.asList(yWords)) );

  return xSet.toArray( new String[xSet.size()] );
}