Java эффективный перебор над символом

Question

Java эффективный перебор над символом

1

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

public int normalize(char s[], int len) {
    for (int i = 0; i < len; i++) {
          switch (s[i]) {
            //numbers
            case EN_D0:
            case AR_D0:
              s[i]= FA_D0;
              break;
            case EN_D1:
            case AR_D1:
              s[i]= FA_D1;
              break;
            case EN_D2:
            case AR_D2:
              s[i]= FA_D2;
              break;
            case EN_D3:
            case AR_D3:
              s[i]= FA_D3;
              break;
            case EN_D4:
            case AR_D4:
              s[i]= FA_D4;
              break;
            case EN_D5:
            case AR_D5:
              s[i]= FA_D5;
              break;
            case EN_D6:
            case AR_D6:
              s[i]= FA_D6;
              break;
            case EN_D7:
            case AR_D7:
              s[i]= FA_D7;
              break;
            case EN_D8:
            case AR_D8:
              s[i]= FA_D8;
              break;
            case EN_D9:
            case AR_D9:
              s[i]= FA_D9;
              break;   
            //Symboles
            case EN_QUESTION_MARK:
              s[i]=FA_QUESTION_MARK;
              break;
            case EN_PERCENT_SIGN:
              s[i]=FA_PERCENT_SIGN;
              break;
            case EN_DASH1:
            case EN_DASH2:
            case EN_DASH3:
            case EN_DASH4:
              s[i]=FA_DASH;
              break;
            case HAMZA_ABOVE:
              len = delete(s, i, len);
              i--;
              break;
            default:
              break;
           }
        }
return len;

Каков наиболее эффективный способ выполнения такого процесса? Пожалуйста, подумайте, что я не поставил здесь все условия, потому что это было около 600 различных условий. Помимо того, что эта часть кода должна быть запущена для огромных документов, которые имеют огромное количество символов. Поэтому эффективность действительно имеет значение.

Ali n 11 апр. 2015, в 09:14

Источник

1

У вас будет много условных проверок, но это кажется неизбежным. Я не думаю, что у тебя получится лучше, чем у тебя.
egracer 11 апр. 2015, в 06:31

Теги:

java

performance

iteration

1 ответ

Ещё вопросы

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

Eran · Accepted Answer · 2015-04-11T03-41-00.000Z

6

Лучший ответ

Если все константы в ваших утверждениях и присваиваниях case являются char s, вы можете использовать массив для сопоставления исходного char для целевого char. Длина массива будет 2^16.

char[] map = new char[65536];

...
map[AR_D7] = FA_D7;
...
map[AR_D9] = FA_D9;
...

Затем вы будете:

for (int i = 0; i < len; i++)
    s[i] = map[s[i]];

Eran 11 апр. 2015, в 03:41

0

Работает ли он более эффективно, чем коммутатор?
Ali n 11 апр. 2015, в 06:38
3

@ Алин, убедитесь, что вы не стали жертвой преждевременной оптимизации !
Qix 11 апр. 2015, в 06:44
1

@ Alin Я полагаю, что так и должно быть, поскольку получение элемента из массива должно выполняться быстрее, чем оператор switch со многими условиями. Это также делает код более лаконичным, что я считаю еще более важным (поскольку прирост производительности не обязательно будет существенным).
Eran 11 апр. 2015, в 07:08
0

@Alin Java иногда довольно умна в оптимизации операторов switch, и если вам повезет, это может даже привести к созданию такого массива. Поскольку использование массива намного понятнее и, по крайней мере, так же быстро, как и коммутатор, я бы всегда пошел на это. +++ Одна проблема с таким большим оператором switch состоит в том, что в нем много кода, и где-то может быть спрятан сюрприз, например, case AR_D8: s[i++]= FA_D8; ,
maaartinus 11 апр. 2015, в 07:37
0

@ Что, если код символа указывает на два разных символа? Например, «\ ufefc» указывает нам на два символа и должен заменить на «\ u0644» и «\ u0627».
Ali n 11 апр. 2015, в 11:57
0

А как насчет случая, когда переменная char указывает на ничто? пожалуйста, посмотрите на главный вопрос.
Ali n 11 апр. 2015, в 12:03
0

@Alin Если это не однозначное сопоставление одного символа с одним символом, вы можете использовать массив String вместо массива char . В этом случае вы не сможете просто назначить один символ для s[i] . Возможно, вы можете использовать StringBuilder и добавлять map[s[i]] к нему для каждого s[i] . Я не уверен, как вы справитесь с этим делом в своем огромном заявлении о переключении.
Eran 11 апр. 2015, в 14:51
0

@Alin Что касается символа, указывающего на ничто, что вы ожидаете случиться? Если вы ожидаете, что s[i] останется неизменным в таком случае, просто инициализируйте массив карты так, чтобы map[s[i]] == s[i]
Eran 11 апр. 2015, в 14:53
0

@Eran Могу ли я использовать NULL Unicode ( '\u0000' ) для случая HAMZA_ABOVE ? Таким образом, я должен добавить эту строку в цикл for: if(map[s[i]]==NULL){ len = delete(s, i, len); i--; }
Ali n 12 апр. 2015, в 04:39
0

@Alin Что делает delete(s, i, len) ?
Eran 12 апр. 2015, в 06:40
0

@Eran Удаляет символ на месте.
Ali n 12 апр. 2015, в 07:10
0

@Eran Я наконец-то преобразовал свою реализацию в ваше предложение, но оно не работает. Моя проблема - условие по умолчанию. Как я могу обработать условие по умолчанию в предложенной вами реализации?
Ali n 12 апр. 2015, в 08:53
0

@Alin Условие по умолчанию означает, что [i] остается неизменным. Чтобы добиться этого с помощью массива map , вы должны инициализировать все элементы массива для map[i]=(char)i; и только затем назначьте не стандартные сопоставления. Таким образом, map[s[i]] всегда будет содержать правильное отображение s[i] .
Eran 12 апр. 2015, в 11:28

Показать ещё 11 комментариев