왜 코드는이 방법으로 String.class의 indexOf() 메서드를 작성합니까?

Question

나는 String.class의 소스 코드를 읽었습니다.
indexOf() 방법에서 나는 내가 이해할 수없는 것을 본다.
여기 indexOf() 코드 스 니펫 String.class 소스 코드입니다.

/** 
* Code shared by String and StringBuffer to do searches. The 
* source is the character array being searched, and the target 
* is the string being searched for. 
* 
* @param source  the characters being searched. 
* @param sourceOffset offset of the source string. 
* @param sourceCount count of the source string. 
* @param target  the characters being searched for. 
* @param targetOffset offset of the target string. 
* @param targetCount count of the target string. 
* @param fromIndex the index to begin searching from. 
*/ 
static int indexOf(char[] source, int sourceOffset, int sourceCount, 
     char[] target, int targetOffset, int targetCount, 
     int fromIndex) { 
    if (fromIndex >= sourceCount) { 
     return (targetCount == 0 ? sourceCount : -1); 
    } 
    if (fromIndex < 0) { 
     fromIndex = 0; 
    } 
    if (targetCount == 0) { 
     return fromIndex; 
    } 

    char first = target[targetOffset]; 
    int max = sourceOffset + (sourceCount - targetCount); 

    for (int i = sourceOffset + fromIndex; i <= max; i++) { 
     /* Look for first character. */ 
     if (source[i] != first) { 
      while (++i <= max && source[i] != first); 
     } 

     /* Found first character, now look at the rest of v2 */ 
     if (i <= max) { 
      int j = i + 1; 
      int end = j + targetCount - 1; 
      for (int k = targetOffset + 1; j < end && source[j] 
        == target[k]; j++, k++); 

      if (j == end) { 
       /* Found whole string. */ 
       return i - sourceOffset; 
      } 
     } 
    } 
    return -1; 
} 

여기서 코드를 이해할 수 없습니다.

if (fromIndex >= sourceCount) { 
    return (targetCount == 0 ? sourceCount : -1); 
} 

source String이 "abcdedefg" 경우, sourceOffset는, sourceCount이 3입니다 2 내가이에서 "D"를 검색하려면, 는 왜 인덱스 4에서 검색 할 수 없습니다?
/**
* Ps : sourceCount이 전체 문자열의 길이를 의미하는 경우 source.length
*을 대신 사용하지 않으시겠습니까? */

Answer 1

이 방법은 두 개의 문자 배열을 허용합니다. source 배열은 검색 할 배열이고 target 배열은 검색 할 배열입니다.

그러나 offset 및 count 변수는 검색을 source의 하위 배열과 target의 하위 배열로 제한합니다.

은 기본적으로 당신은 target[targetOffSet]에서 target[targetOffset+targetCount-1]에 하위 배열의 문자로 구성된 String에 대한 source[sourceOffset+sourceCount-1]에 source[sourceOffSet]에서 하위 배열에서 찾고있다.

다음 그림이 있습니다.

source array : |--------------------| 
sub array :  |-------|   
        source source 
        offset offset + 
          source 
          count - 1 

target array : |--------------------| 
sub array :  |-------|   
        target target 
        offset offset + 
          target 
          count - 1 

그러나, 탐색이 더욱 fromIndex 공급에 의해 제한된다 : 검색에 대한 관련 어레이는 서브 어레이이다. 하위 인덱스 source 하위 인덱스에서 검색을 시작합니다. source 서브 어레이의 길이 이후

는 target 서브 어레이가 비어 않는 정도로 fromIndex >= sourceCount 경우 target 서브 어레이는 -1 반환 (즉 targetCount == 0)를 찾을 수없는, sourceCount이다.

의 당신의 예를 살펴 보자

source : "abcdedefg" 
sourceOffset : 2 
sourceCount : 3 
target : "d" 
targetOffset : 0 
targetCount : 1 
fromIndex : 4 

이러한 매개 변수는 인덱스 4에서 시작하는 대상 하위 문자열 "d"에 대한 소스 하위 문자열 "cde"에서 검색 의미한다. 그러나 색인 4은 "cde"에 없으므로 -1이 리턴됩니다.에 관한

당신의

추신 : sourceCount 전체 문자열의 길이를 의미하는 경우 난의 길이를 의미하지 않는다 sourceCount을 설명하고있는 바와 같이, 왜 source.length 대신

를 사용하지 전체 source 배열, 검색되는 하위 배열의 길이. 당신이 someString.indexOf(str,fromIndex)를 호출 할 때, 당신이 물어 static 방법에 대한 다음과 같은 매개 변수로 호출되고 있음을

가

참고 :이 경우 sourceCount에서

public int indexOf(String str, int fromIndex) { 
    return indexOf(value, 0, value.length, 
      str.value, 0, str.value.length, fromIndex); 
} 

가 source.length 같다 (즉, 전체 source 배열의 시작을 검색하고 있습니다 fromIndex).

Answer 2

if (fromIndex >= sourceCount) { 
     return (targetCount == 0 ? sourceCount : -1); 
    } 

이 검색 인덱스 (fromIndex)에 종료 후에는 것을 말한다
, 문자열 길이 (sourceCount)을 추구 문자열 "" 경우를 제외하고, 다음 (찾을 수 없음) -1 반환 - 항상 "이다 녹이다." 아주 구체적입니다.