Улучшение подсчета частот слов с помощью hashmap

вы можете попробовать реализации дерево префиксов (trie) как структура данных, особенно если вы знаете диапазон символов. Это будет не более 4 уровней, давая вам потенциально постоянное (и более быстрое постоянное) время. Как это будет работать по сравнению с hashmap действительно зависит от данных, которые у вас есть.

редактировать

альтернативно, опять же, если вы знаете диапазон символов, вы можете просто поместить их в гораздо более быстрые данные тип.

поскольку вы знаете, что все ваши символы находятся между A и Z или 0 и 9, вы можете сжать это в 6 бит каждый:

 public int index(String str, int startPos) {
     return 
    ((str.charAt(startPos+3) - '0') << 18) + 
    ((str.charAt(startPos+2) - '0') << 12) + 
    ((str.charAt(startPos+1) - '0') << 6) + 
     (str.charAt(startPos) - '0');
 }

 //...    
 int[] counts = new int[42*42*42*42];
 final int max = text.length() - 4;
 for ( int i = 0; i < max; i++ ) {
     counts[index(text, i)]++;
 }    

редактировать: обновлен пример выше, чтобы покрыть A-Z, 0-9. Теперь обратите внимание на две вещи: Во-первых, вы должны создать большой массив, но вам не нужно делать это каждый раз (вы должны очистить его каждый раз!). Во-вторых, это обеспечивает очень быстрый поиск количества вхождений определенного слова, но если вы хотите повторить все слова (скажем, чтобы найти все слова, которые на самом деле произошли), что занимает O(42^4) времени.

Ну, один из потенциальных вариантов-изменить использование неизменяемые тип обертки к изменяемому:

public final class Counter
{
    private int value;

    public int getValue()
    {
        return value;
    }

    public void increment()
    {
        value++;
    }
}

затем измените ваш код:

private Map<String, Counter> getTetagramCount(final String text) {
    final Map<String, Counter> cipherTetagrams = new HashMap<String, Counter>(200);

    // Micro-optimization (may well not help) - only take the
    // length and subtract 4 once
    int lastStart = text.length() - 4;
    for (int i = 0; i < lastStart; i++) {
        final String tet = text.substring(i, i + 4);

        Counter counter = cipherTetagrams.get(tet);
        if (counter == null) {
            counter = new Counter();
            cipherTetagrams.put(tet, counter);
        }
        counter.increment();
    }

    return cipherTetagrams;
}

таким образом, вы только когда-либо "ставили" значение, связанное со словом один раз... после этого вы увеличиваете его на месте.

(вы могли бы потенциально использовать AtomicInteger вместо Counter Если вы хотите использовать встроенный тип.)

Big-O оптимизация в сторону (если есть), есть очень простой способ значительно ускорить ваше приложение: используйте что-то, чем Java API по умолчанию, которые являются очень медленно, когда дело доходит до борьбы с много данных.

заменить:

Map<String, Counter>

С Trove (что означает, что вы должны добавить банку Trove в свой проект):

TObjectIntHashMap<String>

и:

final Integer count = cipherTetagrams.get(tet);

С:

final int count = cipherTetagrams.get(tet);

потому что когда ты работаешь с много данных, используя обертки, такие как Integer вместо примитивов (например, int), и используя API Java по умолчанию, это самый верный способ застрелиться в ногу.

Я даже не начал анализировать ваш код, и я заметил, что этот метод не работает ни с какими полями-членами и может быть сделан статическим. Статические методы всегда будут работать лучше, чем нестатические методы. Я буду искать другие проблемы через минуту...

Я не уверен, что это будет быстрее, но я чувствую, что это будет.

private Map<String, Integer> getTetagramCount( final String text) {

    final List<String> list = new ArrayList<String>();

    for( int i =0; i < text.length() - 4; i++) {
        list.add( text.substring( i, i+4);
    }

    Collections.sort( list);

    Map<String, Integer> map = new HashMap<String, Integer>( list.size());
    String last = null;
    int count = 0;
    for( String tetagram : list) {
        if( tetagram != last && last != null) {
            map.put( tetagram, count);
            count = 0;
        }
        count++;
        last = tetagram;
    }
    if( tetagram != null) {
        map.put( tetagram, count);
    }
    return map;
}

в зависимости от того, что вы делаете с картой, когда вы закончите, вам может не понадобиться преобразование в карту в конце.