Сканер против StringTokenizer против String.Split

Я только что узнал о классе Java Scanner, и теперь мне интересно, как он сравнивается / конкурирует с StringTokenizer и String.Split. Я знаю, что StringTokenizer и String.Split работают только со строками, так зачем мне использовать сканер для строки? Сканер предназначен только для того, чтобы делать покупки в одном месте?

По сути, они лошади для курсов.

• ScannerПредназначено для случаев, когда нужно разобрать строку, извлекая данные разных типов. Он очень гибкий, но, возможно, не дает вам простейшего API для простого получения массива строк, ограниченных определенным выражением.
• String.split()и Pattern.split()дать вам простой синтаксис для выполнения последнего, но это по сути все, что они делают. Если вы хотите проанализировать результирующие строки или изменить разделитель на полпути в зависимости от конкретного токена, они вам не помогут.
• StringTokenizerэто еще более ограничительно, чем использование String.split(), и немного более неудобно. Он по сути предназначен для извлечения токенов, ограниченных фиксированными подстроками. Из-за этого ограничения это примерно в два раза быстрее String.split(). (См. Мое сравнение String.split()иStringTokenizer .) Это также предшествует API регулярных выражений, частью которого String.split()является.

По моим String.split()временам вы заметите, что на обычной машине можно по-прежнему токенизировать тысячи строк за несколько миллисекунд . Кроме того, он имеет преимущество перед StringTokenizerтем, что дает вывод в виде строкового массива, который обычно является тем, что вы хотите. Использование Enumeration, как предусмотрено StringTokenizer, в большинстве случаев слишком «синтаксически суетливо». С этой точки зрения StringTokenizerв наше время это пустая трата пространства, и вы можете просто использовать String.split().

Давайте начнем с устранения StringTokenizer. Он стареет и даже не поддерживает регулярные выражения. В его документации говорится:

StringTokenizerявляется устаревшим классом, который сохраняется по соображениям совместимости, хотя его использование не рекомендуется в новом коде. Всем, кто ищет эту функцию, рекомендуется использовать splitметод Stringили java.util.regexпакет.

Итак, давайте выбросим это прямо сейчас. Это оставляет split()и Scanner. Какая разница между ними?

Во-первых, split()просто возвращает массив, что упрощает использование цикла foreach:

for (String token : input.split("\\s+") { ... }

Scanner построен больше как поток:

while (myScanner.hasNext()) {
    String token = myScanner.next();
    ...
}

или

while (myScanner.hasNextDouble()) {
    double token = myScanner.nextDouble();
    ...
}

(У него довольно большой API , поэтому не думайте, что он всегда ограничен такими простыми вещами.)

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

Лично я могу вспомнить только один раз, когда использовал Scannerшкольные проекты, когда мне приходилось получать пользовательский ввод из командной строки. Это делает такую ​​операцию легкой. Но если у меня есть то, Stringчто я хочу разделить, это почти легкое дело split().

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

Сплит появился на JDK 1.4. Медленнее, чем токенизатор, но проще в использовании, так как он вызывается из класса String.

Сканер пришел на JDK 1.5. Он является наиболее гибким и заполняет давнишний пробел в Java API для поддержки эквивалента известного семейства функций Cs scanf.

Если у вас есть объект String, который вы хотите токенизировать, используйте метод разделения String вместо StringTokenizer . Если вы анализируете текстовые данные из источника вне вашей программы, например из файла или от пользователя, то здесь вам пригодится сканер.

Сплит медленный, но не такой медленный, как сканер. StringTokenizer быстрее, чем сплит. Однако я обнаружил, что могу получить двойную скорость, торгуя некоторой гибкостью, чтобы получить повышение скорости, что я и сделал на JFastParser https://github.com/hughperkins/jfastparser

Тестирование на строке, содержащей миллион дублей:

Scanner: 10642 ms
Split: 715 ms
StringTokenizer: 544ms
JFastParser: 290ms

String.split, кажется, намного медленнее, чем StringTokenizer. Единственным преимуществом split является то, что вы получаете массив токенов. Также вы можете использовать любые регулярные выражения в split. org.apache.commons.lang.StringUtils имеет метод split, который работает намного быстрее, чем любой из двух, а именно. StringTokenizer или String.split. Но загрузка ЦП для всех трех почти одинакова. Поэтому нам также нужен метод, который требует меньше ресурсов процессора, но я до сих пор не могу его найти.

Недавно я провел несколько экспериментов по поводу плохой производительности String.split () в ситуациях с высокой производительностью. Вы можете найти это полезным.

http://eblog.chrononsystems.com/hidden-evils-of-javas-stringsplit-and-stringr

Суть в том, что String.split () каждый раз компилирует шаблон регулярного выражения и, таким образом, может замедлить вашу программу по сравнению с тем, если вы используете предварительно скомпилированный объект Pattern и используете его напрямую для работы со строкой.

Для сценариев по умолчанию я бы также предложил Pattern.split (), но если вам нужна максимальная производительность (особенно на Android, все протестированные мной решения работают довольно медленно) и вам нужно разделить только на один символ, я теперь использую свой собственный метод:

public static ArrayList<String> splitBySingleChar(final char[] s,
        final char splitChar) {
    final ArrayList<String> result = new ArrayList<String>();
    final int length = s.length;
    int offset = 0;
    int count = 0;
    for (int i = 0; i < length; i++) {
        if (s[i] == splitChar) {
            if (count > 0) {
                result.add(new String(s, offset, count));
            }
            offset = i + 1;
            count = 0;
        } else {
            count++;
        }
    }
    if (count > 0) {
        result.add(new String(s, offset, count));
    }
    return result;
}

Используйте «abc» .toCharArray (), чтобы получить массив char для String. Например:

String s = "     a bb   ccc  dddd eeeee  ffffff    ggggggg ";
ArrayList<String> result = splitBySingleChar(s.toCharArray(), ' ');

Одно важное отличие состоит в том, что и String.split (), и Scanner могут создавать пустые строки, но StringTokenizer никогда этого не делает.

Например:

String str = "ab cd  ef";

StringTokenizer st = new StringTokenizer(str, " ");
for (int i = 0; st.hasMoreTokens(); i++) System.out.println("#" + i + ": " + st.nextToken());

String[] split = str.split(" ");
for (int i = 0; i < split.length; i++) System.out.println("#" + i + ": " + split[i]);

Scanner sc = new Scanner(str).useDelimiter(" ");
for (int i = 0; sc.hasNext(); i++) System.out.println("#" + i + ": " + sc.next());

Вывод:

//StringTokenizer
#0: ab
#1: cd
#2: ef
//String.split()
#0: ab
#1: cd
#2: 
#3: ef
//Scanner
#0: ab
#1: cd
#2: 
#3: ef

Это связано с тем, что разделитель для String.split () и Scanner.useDelimiter () является не просто строкой, а регулярным выражением. Мы можем заменить разделитель "" на "+" в приведенном выше примере, чтобы заставить их вести себя как StringTokenizer.

String.split () работает очень хорошо, но имеет свои границы, например, если вы хотите разбить строку, как показано ниже на основе символа одинарной или двойной трубы (|), она не работает. В этой ситуации вы можете использовать StringTokenizer.

ABC | IJK