Как я добавляю текстовые поля динамично в JavaScript?

Некоторые результаты испытаний

я добрался, много хороших ответов на этот вопрос - благодарит людей - таким образом, я решил запустить некоторые тесты и фигуру, какой метод является на самом деле самым быстрым. Эти пять методов, которые я протестировал, являются ими:

• методика "ContainsKey", которую я представил в вопрос
• метод "TestForNull", предложенный Aleksandar Dimitrov
• метод "AtomicLong", предложенный Hank Gay
• метод "Находки", предложенный jrudolph
• метод "MutableInt", предложенный phax.myopenid.com

Метод

Здесь, - то, что я сделал...

1. создал пять классов, которые были идентичны за исключением различий, показанных ниже. Каждый класс должен был выполнить операцию, типичную для сценария, который я представил: открытие файла 10 МБ и чтение его в, затем выполняя подсчет частот всех словоупотреблений в файле. Так как это заняло в среднем только 3 секунды, у меня был он, выполняют подсчет частот (не ввод-вывод) 10 раз.
2. синхронизировал цикл 10 повторений, но не операция ввода-вывода и записала потраченное общее время (в секунды часов) по существу использование метод Ian Darwin в Поваренной книге Java .
3. выполнил все пять тестов последовательно, и затем сделал это еще три раза.
4. составил в среднем четыре результата для каждого метода.

Результаты

я представлю результаты сначала и код ниже для тех, кому интересно.

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

• ContainsKey: 30,654 секунды (базовая линия)
• AtomicLong: 29,780 секунд (в 1.03 раза более быстрых)
• TestForNull: 28,804 секунд (в 1.06 раза более быстрых)
• Находка: 26,313 секунд (в 1.16 раза более быстрых)
• MutableInt: 25,747 секунд (в 1.19 раза более быстрых)

Заключения

, казалось бы, что только метод MutableInt и метод Находки значительно быстрее в том единственном, которое они дают повышению производительности больше чем 10%. Однако, если поточная обработка является проблемой, AtomicLong мог бы быть более привлекательным, чем другие (я не действительно уверен). Я также выполнил TestForNull с final переменные, но различие было незначительно.

Примечание, что я не представил использование памяти в различных сценариях. Я был бы рад получить известие от кого-либо, у кого есть хорошее понимание того, как методы MutableInt и Находки, вероятно, влияли бы на использование памяти.

Лично, я нахожу метод MutableInt самым привлекательным, так как он не требует загрузки никаких сторонних классов. Таким образом, если я не обнаруживаю проблемы с ним, это - путь, которым я, скорее всего, пойду.

код

Вот решающий код из каждого метода.

находка ContainsKey

import java.util.HashMap;
import java.util.Map;
...
Map freq = new HashMap();
...
int count = freq.containsKey(word) ? freq.get(word) : 0;
freq.put(word, count + 1);

TestForNull

import java.util.HashMap;
import java.util.Map;
...
Map freq = new HashMap();
...
Integer count = freq.get(word);
if (count == null) {
    freq.put(word, 1);
}
else {
    freq.put(word, count + 1);
}

AtomicLong

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;
...
final ConcurrentMap map = 
    new ConcurrentHashMap();
...
map.putIfAbsent(word, new AtomicLong(0));
map.get(word).incrementAndGet();

import gnu.trove.TObjectIntHashMap;
...
TObjectIntHashMap freq = new TObjectIntHashMap();
...
freq.adjustOrPutValue(word, 1, 1);

MutableInt

import java.util.HashMap;
import java.util.Map;
...
class MutableInt {
  int value = 1; // note that we start at 1 since we're counting
  public void increment () { ++value;      }
  public int  get ()       { return value; }
}
...
Map freq = new HashMap();
...
MutableInt count = freq.get(word);
if (count == null) {
    freq.put(word, new MutableInt());
}
else {
    count.increment();
}