Метод разделения по подстроке и IndexOf

Question

поэтому я пишу программу, которая анализирует CSV. Я использую метод split для разделения значений в строковый массив, но в некоторых статьях я читал, что быстрее использовать подстроку и indexOf. Я написал, что я буду делать с этими двумя методами, и похоже, что раскол был бы лучше. Может ли кто-нибудь объяснить, как это лучше, или, может быть, я неправильно использую эти методы? Вот что я написал:

int indexOne = 0, indexTwo; 
for (int i = 0; i < 4; i++) //there's four diff values in one line 
{ 
    if (line.indexOf(",", indexOne) != -1) 
    { 
     indexTwo = line.indexOf(",", indexOne); 
     lineArr[i] = line.substring(indexOne, indexTwo); 
     indexOne = indexTwo+1; 
    } 
} 

Answer 1

ниже код взят из источника поставляется с оракулы JDK 8 обновлением 73. Как вы можете увидеть в сценарии «FastPath», когда вы проходите в один-символьной строке, он падает цикл с использованием indexOf, аналогичный вашей логике.

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

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

public String[] split(String regex, int limit) { 
    /* fastpath if the regex is a 
    (1)one-char String and this character is not one of the 
     RegEx's meta characters ".$|()[{^?*+\\", or 
    (2)two-char String and the first char is the backslash and 
     the second is not the ascii digit or ascii letter. 
    */ 
    char ch = 0; 
    if (((regex.value.length == 1 && 
     ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) || 
     (regex.length() == 2 && 
      regex.charAt(0) == '\\' && 
      (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 && 
      ((ch-'a')|('z'-ch)) < 0 && 
      ((ch-'A')|('Z'-ch)) < 0)) && 
     (ch < Character.MIN_HIGH_SURROGATE || 
     ch > Character.MAX_LOW_SURROGATE)) 
    { 
     int off = 0; 
     int next = 0; 
     boolean limited = limit > 0; 
     ArrayList<String> list = new ArrayList<>(); 
     while ((next = indexOf(ch, off)) != -1) { 
      if (!limited || list.size() < limit - 1) { 
       list.add(substring(off, next)); 
       off = next + 1; 
      } else { // last one 
       //assert (list.size() == limit - 1); 
       list.add(substring(off, value.length)); 
       off = value.length; 
       break; 
      } 
     } 
     // If no match was found, return this 
     if (off == 0) 
      return new String[]{this}; 

     // Add remaining segment 
     if (!limited || list.size() < limit) 
      list.add(substring(off, value.length)); 

     // Construct result 
     int resultSize = list.size(); 
     if (limit == 0) { 
      while (resultSize > 0 && list.get(resultSize - 1).length() == 0) { 
       resultSize--; 
      } 
     } 
     String[] result = new String[resultSize]; 
     return list.subList(0, resultSize).toArray(result); 
    } 
    return Pattern.compile(regex).split(this, limit); 
}