Строки

import java.util.*;
 
interface WordsMapper {
    String DEFAULT_WORD_SEPARATORS = " !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
    Map<String, Integer> mapWords(String source);
}
 
class SplitWordsMapper implements WordsMapper {
    @Override
    public Map<String, Integer> mapWords(String source) {
        Map<String, Integer> wordsCounterMap = new TreeMap<String, java.lang.Integer>(String.CASE_INSENSITIVE_ORDER);
 
        String [] words = source.split("[ \\p{Punct}]+");
        for (String word : words) {
            if (!wordsCounterMap.containsKey(word)) {
                wordsCounterMap.put(word.toLowerCase(), 1);
            } else {
                wordsCounterMap.put(word, wordsCounterMap.get(word) + 1);
            }
        }
 
        return wordsCounterMap;
    }
}
 
/**
 * StringTokenizer is a legacy class that is retained for compatibility reasons although its use is discouraged
 * in new code. It is recommended that anyone seeking this functionality use the split method of String or the
 * java.util.regex package instead.
 * {@see <a href="http://docs.oracle.com/javase/7/docs/api/java/util/StringTokenizer.html">Java Documentation</a>}
 */
@Deprecated
class TokenizerWordsMapper implements WordsMapper {
    @Override
    public Map<String, Integer> mapWords(String source) {
        Map<String, Integer> wordsCounterMap = new TreeMap<String, java.lang.Integer>(String.CASE_INSENSITIVE_ORDER);
 
        StringTokenizer tokenizer = new StringTokenizer(source, DEFAULT_WORD_SEPARATORS);
        while (tokenizer.hasMoreTokens()) {
            String word = tokenizer.nextToken();
            if (!wordsCounterMap.containsKey(word)) {
                wordsCounterMap.put(word.toLowerCase(), 1);
            } else {
                wordsCounterMap.put(word, wordsCounterMap.get(word) + 1);
            }
        }
        return wordsCounterMap;
    }
}
 
enum WordsMappers {
    SPLIT("Split words mapper", new SplitWordsMapper()),
    TOKENIZER("Tokenizer words mapper", new TokenizerWordsMapper());
    private WordsMapper wordsMapper;
    private String name;
    WordsMappers(String name, WordsMapper wordsMapper) {
        this.name = name;
        this.wordsMapper = wordsMapper;
    }
 
    public WordsMapper getWordsMapper() {
        return wordsMapper;
    }
 
    public String getName() {
        return name;
    }
}
 
public class Tutorial0009 {
    private final static Random random = new Random();
 
    private static String getRandomString(int length) {
        String letters = "abcdefghijklmnopqrstuvwxyz";
        StringBuilder result = new StringBuilder(length);
        while (length-- > 0) {
            if (random.nextInt(10) == 0) {
                result.append(WordsMapper.DEFAULT_WORD_SEPARATORS.charAt(random.nextInt(WordsMapper.DEFAULT_WORD_SEPARATORS.length())));
            } else {
                result.append(letters.charAt(random.nextInt(letters.length())));
            }
        }
        return result.toString();
    }
 
    private static volatile Map<String, Integer> result = null;
    private static double checkPerformance(WordsMapper wordsMapper, long numberOfTries, int randomStringSize) {
        long sideLoss = 0;
        long begin = System.nanoTime();
 
        for (int i = 0; i < numberOfTries; ++i) {
            long beginSideLoss = System.nanoTime();
            String randomString = getRandomString(randomStringSize);
            sideLoss += System.nanoTime() - beginSideLoss;
 
            result = wordsMapper.mapWords(randomString);
        }
        long end = System.nanoTime();
 
        return (double)(numberOfTries * 1000000000) / (end - begin - sideLoss) ;
    }
 
    public static void main(String[] args) {
        String source = "Создается строка из n слов. Посчитать в ней количество слов, которые содержат одинаковые наборы символов(в независимости от положения и регистра). Использовать String и StringBuffer, StringTokenizer, сравнить производительность. Вопрос: как посчитать количество слов, которые содержат одинаковые наборы символов?";
 
        for (WordsMappers wordsMapper : WordsMappers.values()) {
            for (int numberOfTries = 10; numberOfTries < 100000; numberOfTries *= 10)
                for (int randomStringLength = 10; randomStringLength < 100000; randomStringLength *= 10) {
                    double performance = checkPerformance(wordsMapper.getWordsMapper(), numberOfTries, randomStringLength);
                    System.out.println("Number of tries = " + numberOfTries +
                        ", random string length = " + randomStringLength +
                        ", " + wordsMapper.getName() + ": " +
                         + performance +
                        " parses per second.");
                }
        }
    }
}