Каков самый простой / лучший / самый правильный способ перебора символов строки в Java?

Я использую цикл for для перебора строки и использую charAt() для проверки каждого символа. Поскольку String реализован с помощью массива, метод charAt() является операцией с постоянным временем.

String s = "...stuff...";

for (int i = 0; i < s.length(); i++){
    char c = s.charAt(i);        
    //Process char
}

Я бы так и поступил. Мне это кажется самым простым.

Что касается правильности, я не верю, что она здесь существует. Все основано на вашем личном стиле.

Я бы не стал использовать StringTokenizer, поскольку это один из устаревших классов JDK.

В javadoc говорится:

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.

См. Учебники по Java: строки.

public class StringDemo {
    public static void main(String[] args) {
        String palindrome = "Dot saw I was Tod";
        int len = palindrome.length();
        char[] tempCharArray = new char[len];
        char[] charArray = new char[len];

        // put original string in an array of chars
        for (int i = 0; i < len; i++) {
            tempCharArray[i] = palindrome.charAt(i);
        } 

        // reverse array of chars
        for (int j = 0; j < len; j++) {
            charArray[j] = tempCharArray[len - 1 - j];
        }

        String reversePalindrome =  new String(charArray);
        System.out.println(reversePalindrome);
    }
}

Поместите длину в int len и используйте петлю for.

Для этого есть несколько специальных классов:

import java.text.*;

final CharacterIterator it = new StringCharacterIterator(s);
for(char c = it.first(); c != CharacterIterator.DONE; c = it.next()) {
   // process c
   ...
}

Два варианта

for(int i = 0, n = s.length() ; i < n ; i++) { 
    char c = s.charAt(i); 
}

или же

for(char c : s.toCharArray()) {
    // process c
}

Первый, вероятно, быстрее, а второй, вероятно, более читабелен.

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

String[] theChars = str.split("|");

Но StringTokenizer не использует регулярные выражения, и вы не можете указать строку-разделитель, которая будет соответствовать ничему между символами. является - один симпатичный маленький прием, который вы можете использовать для достижения того же самого: использовать саму строку в качестве строки-разделителя (делая каждый символ в ней разделителем) и заставить ее возвращать разделители:

StringTokenizer st = new StringTokenizer(str, str, true);

Однако я упоминаю эти варианты только для того, чтобы от них отказаться. Оба метода разбивают исходную строку на односимвольные строки, а не на примитивы типа char, и оба связаны с большими накладными расходами в виде создания объектов и манипуляций со строками. Сравните это с вызовом charAt () в цикле for, который практически не требует накладных расходов.

Я согласен, что StringTokenizer здесь излишний. На самом деле я попробовал приведенные выше предложения и не торопился.

Мой тест был довольно простым: создать StringBuilder примерно с миллионом символов, преобразовать его в String и пройти каждый из них с помощью charAt () / после преобразования в массив char / с помощью CharacterIterator тысячу раз (конечно, убедитесь, что сделать что-нибудь со строкой, чтобы компилятор не смог оптимизировать весь цикл :-)).

Результат на моем Powerbook 2,6 ГГц (это Mac :-)) и JDK 1.5:

• Тест 1: charAt + String -> 3138 мсек.
• Тест 2: строка преобразована в массив -> 9568 мсек.
• Тест 3: StringBuilder charAt -> 3536 мс
• Тест 4: CharacterIterator и String -> 12151 мс

Поскольку результаты значительно отличаются, самый простой способ также кажется самым быстрым. Интересно, что charAt () StringBuilder кажется немного медленнее, чем String.

Кстати, я предлагаю не использовать CharacterIterator, поскольку считаю злоупотребление символом '\ uFFFF' "концом итерации" действительно ужасным взломом. В больших проектах всегда есть два парня, которые используют один и тот же хак для двух разных целей, и код действительно загадочно дает сбой.

Вот один из тестов:

    int count = 1000;
    ...

    System.out.println("Test 1: charAt + String");
    long t = System.currentTimeMillis();
    int sum=0;
    for (int i=0; i<count; i++) {
        int len = str.length();
        for (int j=0; j<len; j++) {
            if (str.charAt(j) == 'b')
                sum = sum + 1;
        }
    }
    t = System.currentTimeMillis()-t;
    System.out.println("result: "+ sum + " after " + t + "msec");

Обратите внимание, что большинство других описанных здесь методов не работают, если вы имеете дело с символами вне BMP (Unicode Базовая многоязычная плоскость), то есть кодовые точки, которые находятся за пределами диапазона u0000-uFFFF. Это будет происходить редко, поскольку кодовые точки за пределами этого в основном относятся к мертвым языкам. Но есть некоторые полезные символы за пределами этого, например, некоторые точки кода используются для математической записи, а некоторые используются для кодирования имен собственных на китайском языке.

В этом случае ваш код будет:

String str = "....";
int offset = 0, strLen = str.length();
while (offset < strLen) {
  int curChar = str.codePointAt(offset);
  offset += Character.charCount(curChar);
  // do something with curChar
}

Для метода Character.charCount(int) требуется Java 5+.

Источник: http://mindprod.com/jgloss/codepoint.html

Если у вас есть Гуава в вашем пути к классам, следующая альтернатива является довольно удобочитаемой. У Guava даже есть довольно разумная реализация кастомного списка для этого случая, так что это не должно быть неэффективным.

for(char c : Lists.charactersOf(yourString)) {
    // Do whatever you want     
}

ОБНОВЛЕНИЕ: как отметил @Alex, с Java 8 также можно использовать CharSequence#chars. Даже типом является IntStream, поэтому его можно сопоставить с такими символами, как:

yourString.chars()
        .mapToObj(c -> Character.valueOf((char) c))
        .forEach(c -> System.out.println(c)); // Or whatever you want

Если вам нужно перебрать кодовые точки String (см. Этот отвечать), более короткий / более читаемый способ - использовать метод CharSequence#codePoints, добавленный в Java 8:

for(int c : string.codePoints().toArray()){
    ...
}

или используя поток напрямую вместо цикла for:

string.codePoints().forEach(c -> ...);

Также существует CharSequence#chars, если вам нужен поток символов (хотя это IntStream, поскольку CharStream отсутствует).

Прорабатываем этот ответ и этот ответ.

Приведенные выше ответы указывают на проблему многих решений здесь, которые не повторяются по значению кодовой точки - у них будут проблемы с любым суррогатные символы. В документации java также описывается проблема здесь (см. «Представления символов Unicode»). Во всяком случае, вот код, который использует некоторые фактические суррогатные символы из дополнительного набора Unicode и преобразует их назад в String. Обратите внимание, что .toChars () возвращает массив символов: если вы имеете дело с суррогатами, у вас обязательно будет два символа. Этот код должен работать с символом Unicode Любые.

    String supplementary = "Some Supplementary: ????";
    supplementary.codePoints().forEach(cp -> 
            System.out.print(new String(Character.toChars(cp))));

Этот пример кода поможет вам!

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class Solution {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 10);
        map.put("b", 30);
        map.put("c", 50);
        map.put("d", 40);
        map.put("e", 20);
        System.out.println(map);

        Map sortedMap = sortByValue(map);
        System.out.println(sortedMap);
    }

    public static Map sortByValue(Map unsortedMap) {
        Map sortedMap = new TreeMap(new ValueComparator(unsortedMap));
        sortedMap.putAll(unsortedMap);
        return sortedMap;
    }

}

class ValueComparator implements Comparator {
    Map map;

    public ValueComparator(Map map) {
        this.map = map;
    }

    public int compare(Object keyA, Object keyB) {
        Comparable valueA = (Comparable) map.get(keyA);
        Comparable valueB = (Comparable) map.get(keyB);
        return valueB.compareTo(valueA);
    }
}

В Java 8 мы можем решить это как:

String str = "xyz";
str.chars().forEachOrdered(i -> System.out.print((char)i));
str.codePoints().forEachOrdered(i -> System.out.print((char)i));

Метод chars () возвращает IntStream, как указано в док:

Returns a stream of int zero-extending the char values from this sequence. Any char which maps to a surrogate code point is passed through uninterpreted. If the sequence is mutated while the stream is being read, the result is undefined.

Метод codePoints() также возвращает IntStream согласно документу:

Returns a stream of code point values from this sequence. Any surrogate pairs encountered in the sequence are combined as if by Character.toCodePoint and the result is passed to the stream. Any other code units, including ordinary BMP characters, unpaired surrogates, and undefined code units, are zero-extended to int values which are then passed to the stream.

Чем отличаются char и code point? Как упоминалось в статье это:

Unicode 3.1 added supplementary characters, bringing the total number of characters to more than the 2^16 = 65536 characters that can be distinguished by a single 16-bit char. Therefore, a char value no longer has a one-to-one mapping to the fundamental semantic unit in Unicode. JDK 5 was updated to support the larger set of character values. Instead of changing the definition of the char type, some of the new supplementary characters are represented by a surrogate pair of two char values. To reduce naming confusion, a code point will be used to refer to the number that represents a particular Unicode character, including supplementary ones.

Наконец, почему forEachOrdered, а не forEach?

Поведение forEach явно недетерминировано, поскольку forEachOrdered выполняет действие для каждого элемента этого потока в порядок встреч в потоке, если поток имеет определенный порядок встречи. Таким образом, forEach не гарантирует соблюдение порядка. Также проверьте этот вопрос для получения дополнительной информации.

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

Если вам нужна производительность, тогда вы должен проверить в своей среде. Другого пути нет.

Вот пример кода:

int tmp = 0;
String s = new String(new byte[64*1024]);
{
    long st = System.nanoTime();
    for(int i = 0, n = s.length(); i < n; i++) {
        tmp += s.charAt(i);
    }
    st = System.nanoTime() - st;
    System.out.println("1 " + st);
}

{
    long st = System.nanoTime();
    char[] ch = s.toCharArray();
    for(int i = 0, n = ch.length; i < n; i++) {
        tmp += ch[i];
    }
    st = System.nanoTime() - st;
    System.out.println("2 " + st);
}
{
    long st = System.nanoTime();
    for(char c : s.toCharArray()) {
        tmp += c;
    }
    st = System.nanoTime() - st;
    System.out.println("3 " + st);
}
System.out.println("" + tmp);

На Java онлайн я получаю:

1 10349420
2 526130
3 484200
0

В Android x86 API 17 я получаю:

1 9122107
2 13486911
3 12700778
0

Так что обычно есть два способа перебрать строку в java, на которую уже ответили несколько человек здесь, в этом потоке, просто добавив мою версию. Сначала использует

String s = sc.next() // assuming scanner class is defined above
for(int i=0; i<s.length; i++){
     s.charAt(i)   // This being the first way and is a constant time operation will hardly add any overhead
  }

char[] str = new char[10];
str = s.toCharArray() // this is another way of doing so and it takes O(n) amount of time for copying contents from your string class to character array

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