Array.IndexOf Array.IndexOf Array.IndexOf Array.IndexOf Method

정의

지정한 개체를 검색하여 1차원 배열 또는 배열의 요소 범위에서 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array or in a range of elements in the array.

오버로드

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

지정한 개체를 검색하여 1차원 배열에서 처음 검색된 개체의 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. 범위는 지정한 인덱스에서 배열의 끝까지 확장됩니다.The range extends from a specified index to the end of the array.

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. 범위는 지정한 요소 수에 대해 지정한 인덱스에서 확장됩니다.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. 범위는 지정한 요소 수에 대해 지정한 인덱스에서 확장됩니다.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

지정한 개체를 검색하여 1차원 배열에서 처음 검색된 개체의 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. 범위는 지정한 인덱스에서 배열의 끝까지 확장됩니다.The range extends from a specified index to the end of the array.

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

지정한 개체를 검색하여 1차원 배열에서 처음 검색된 개체의 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

public:
 static int IndexOf(Array ^ array, System::Object ^ value);
public static int IndexOf (Array array, object value);
static member IndexOf : Array * obj -> int

매개 변수

array
Array Array Array Array

검색할 1차원 배열입니다.The one-dimensional array to search.

value
Object Object Object Object

array에서 찾을 개체입니다.The object to locate in array.

반환

value가 있을 경우 array에서 처음 검색된 값의 인덱스이고, 그렇지 않으면 배열의 하한에서 1을 뺀 값입니다.The index of the first occurrence of value in array, if found; otherwise, the lower bound of the array minus 1.

예외

array가 다차원 배열인 경우array is multidimensional.

예제

다음 세 가지 오버 로드를 호출 하는 예제를 IndexOf 메서드 문자열 배열에서 문자열의 인덱스를 찾으려면:The example calls the following three overloads of the IndexOf method to find the index of a string in a string array:

  • IndexOf(Array, Object)를 문자열의 첫 번째 발생을 확인 하는 문자열 배열에서 "the"입니다.IndexOf(Array, Object), to determine the first occurrence of the string "the" in a string array.

  • IndexOf(Array, Object, Int32)를 문자열의 첫 번째 발생을 확인 하려면 "the" 문자열 배열의 마지막 요소에는 네 번째에 있습니다.IndexOf(Array, Object, Int32), to determine the first occurrence of the string "the" in the fourth to the last elements of a string array.

  • IndexOf(Array, Object, Int32, Int32)를 문자열의 첫 번째 발생을 확인 하려면 문자열에서 "the" 배열에서 마지막으로 성공한 일치 항목을 배열의 끝에 다음에 나오는 요소가 있습니다.IndexOf(Array, Object, Int32, Int32), to determine the first occurrence of the string "the" in a string array from the element that follows the last successful match to the end of the array.

using namespace System;

void main()
{
   // Create a string array with 3 elements having the same value.
   array<String^>^ strings = { "the", "quick", "brown", "fox",
                               "jumps", "over", "the", "lazy", "dog",
                               "in", "the", "barn" };

   // Display the elements of the array.
   Console::WriteLine("The array contains the following values:");
   for (int i = strings->GetLowerBound(0); i <= strings->GetUpperBound(0); i++)
      Console::WriteLine("   [{0,2}]: {1}", i, strings[i]);
      
   // Search for the first occurrence of the duplicated value.
   String^ searchString =  "the";
   int index = Array::IndexOf(strings, searchString);
   Console::WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in the last section of the array.
   index = Array::IndexOf( strings, searchString, 4);
   Console::WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in a section of the array.
   int position = index + 1;
   index = Array::IndexOf(strings, searchString, position, strings->GetUpperBound(0) - position + 1);
   Console::WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                      searchString, position, strings->GetUpperBound(0), index);
}
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
using System;

public class Example
{
    public static void Main()
    {
       // Create a string array with 3 elements having the same value.
       String[] strings = { "the", "quick", "brown", "fox", "jumps",
                            "over", "the", "lazy", "dog", "in", "the",
                            "barn" };

       // Display the elements of the array.
       Console.WriteLine("The array contains the following values:");
       for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
          Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);

       // Search for the first occurrence of the duplicated value.
       String searchString = "the";
       int index = Array.IndexOf(strings, searchString);
       Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in the last section of the array.
       index = Array.IndexOf(strings, searchString, 4);
       Console.WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in a section of the array.
       int position = index + 1;
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
       Console.WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index);
    }
 }
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
Public Module Example
   Public Sub Main()
      ' Create a string array with 3 elements having the same value.
      Dim strings() As String = { "the", "quick", "brown", "fox",
                                  "jumps", "over", "the", "lazy",
                                  "dog", "in", "the", "barn" }

      ' Display the values of the array.
      Console.WriteLine("The array contains the following values:")
      For i As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
         Console.WriteLine("   [{0,2}]: {1}", i, strings(i))
      Next

      ' Search for the first occurrence of the duplicated value.
      Dim searchString As String = "the"
      Dim index As Integer = Array.IndexOf(strings, searchString)
      Console.WriteLine("The first occurrence of ""{0}"" is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in the last section of the array.
      index = Array.IndexOf(strings, searchString, 4)
      Console.WriteLine("The first occurrence of ""{0}"" between index 4 and the end is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in a section of the array.
       Dim position As Integer = index + 1
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1)
       Console.WriteLine("The first occurrence of ""{0}"" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index)
    End Sub
End Module
' The example displays the following output:
'    The array contains the following values:
'       [ 0]: the
'       [ 1]: quick
'       [ 2]: brown
'       [ 3]: fox
'       [ 4]: jumps
'       [ 5]: over
'       [ 6]: the
'       [ 7]: lazy
'       [ 8]: dog
'       [ 9]: in
'       [10]: the
'       [11]: barn
'    The first occurrence of "the" is at index 0.
'    The first occurrence of "the" between index 4 and the end is at index 6.
'    The first occurrence of "the" between index 7 and index 11 is at index 10.

설명

이 메서드 검색의 1 차원 배열의 모든 요소 value합니다.This method searches all the elements of a one-dimensional array for value. 결정할 여부를 value 에 있는 array, 각 요소를 호출 하 여 같음 비교를 수행 하는 메서드 Equals 일치 항목을 찾을 때까지 메서드.To determine whether value exists in array, the method performs an equality comparison by calling each element's Equals method until it finds a match. 즉, 요소를 재정의 하는 경우는 Object.Equals(Object) 메서드를 재정의 하는 호출 됩니다.This means that if the element overrides the Object.Equals(Object) method, that override is called.

대부분의 배열은 하 한이 0 이므로이 메서드는 일반적으로 @ no__t-0을 찾을 수 없는 경우-1을 반환 합니다.Because most arrays have a lower bound of zero, this method generally returns -1 ifvalue isn't found. 드문 경우 이지만 해당 하는 배열의 하한값 Int32.MinValue(0x80000000) 및 value 를 찾을 수 없으면이 메서드는 반환 Int32.MaxValue (0x7FFFFFFF).In the rare case that the lower bound of the array is equal to Int32.MinValue(0x80000000) and value isn't found, this method returns Int32.MaxValue (0x7FFFFFFF).

이 메서드는 O (n) 작업을 여기서 nLengtharray합니다.This method is an O(n) operation, where n is the Length of array.

추가 정보

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. 범위는 지정한 인덱스에서 배열의 끝까지 확장됩니다.The range extends from a specified index to the end of the array.

public:
 static int IndexOf(Array ^ array, System::Object ^ value, int startIndex);
public static int IndexOf (Array array, object value, int startIndex);
static member IndexOf : Array * obj * int -> int

매개 변수

array
Array Array Array Array

검색할 1차원 배열입니다.The one-dimensional array to search.

value
Object Object Object Object

array에서 찾을 개체입니다.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

검색할 시작 인덱스입니다.The starting index of the search. 0은 빈 배열에서 유효합니다.0 (zero) is valid in an empty array.

반환

value가 있을 경우 startIndex에서 마지막 요소로 확장하는 array의 요소 범위에서 처음 검색된 값의 인덱스이고, 그렇지 않으면 배열의 하한에서 1을 뺀 값입니다.The index of the first occurrence of value, if it's found, within the range of elements in array that extends from startIndex to the last element; otherwise, the lower bound of the array minus 1.

예외

startIndexarray의 유효한 인덱스 범위를 벗어납니다.startIndex is outside the range of valid indexes for array.

array가 다차원 배열인 경우array is multidimensional.

예제

다음 세 가지 오버 로드를 호출 하는 예제를 IndexOf 메서드 문자열 배열에서 문자열의 인덱스를 찾으려면:The example calls the following three overloads of the IndexOf method to find the index of a string in a string array:

  • IndexOf(Array, Object)를 문자열의 첫 번째 발생을 확인 하는 문자열 배열에서 "the"입니다.IndexOf(Array, Object), to determine the first occurrence of the string "the" in a string array.

  • IndexOf(Array, Object, Int32)를 문자열의 첫 번째 발생을 확인 하려면 "the" 문자열 배열의 마지막 요소에는 네 번째에 있습니다.IndexOf(Array, Object, Int32), to determine the first occurrence of the string "the" in the fourth to the last elements of a string array.

  • IndexOf(Array, Object, Int32, Int32)를 문자열의 첫 번째 발생을 확인 하려면 문자열에서 "the" 배열에서 마지막으로 성공한 일치 항목을 배열의 끝에 다음에 나오는 요소가 있습니다.IndexOf(Array, Object, Int32, Int32), to determine the first occurrence of the string "the" in a string array from the element that follows the last successful match to the end of the array.

using namespace System;

void main()
{
   // Create a string array with 3 elements having the same value.
   array<String^>^ strings = { "the", "quick", "brown", "fox",
                               "jumps", "over", "the", "lazy", "dog",
                               "in", "the", "barn" };

   // Display the elements of the array.
   Console::WriteLine("The array contains the following values:");
   for (int i = strings->GetLowerBound(0); i <= strings->GetUpperBound(0); i++)
      Console::WriteLine("   [{0,2}]: {1}", i, strings[i]);
      
   // Search for the first occurrence of the duplicated value.
   String^ searchString =  "the";
   int index = Array::IndexOf(strings, searchString);
   Console::WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in the last section of the array.
   index = Array::IndexOf( strings, searchString, 4);
   Console::WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in a section of the array.
   int position = index + 1;
   index = Array::IndexOf(strings, searchString, position, strings->GetUpperBound(0) - position + 1);
   Console::WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                      searchString, position, strings->GetUpperBound(0), index);
}
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
using System;

public class Example
{
    public static void Main()
    {
       // Create a string array with 3 elements having the same value.
       String[] strings = { "the", "quick", "brown", "fox", "jumps",
                            "over", "the", "lazy", "dog", "in", "the",
                            "barn" };

       // Display the elements of the array.
       Console.WriteLine("The array contains the following values:");
       for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
          Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);

       // Search for the first occurrence of the duplicated value.
       String searchString = "the";
       int index = Array.IndexOf(strings, searchString);
       Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in the last section of the array.
       index = Array.IndexOf(strings, searchString, 4);
       Console.WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in a section of the array.
       int position = index + 1;
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
       Console.WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index);
    }
 }
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
Public Module Example
   Public Sub Main()
      ' Create a string array with 3 elements having the same value.
      Dim strings() As String = { "the", "quick", "brown", "fox",
                                  "jumps", "over", "the", "lazy",
                                  "dog", "in", "the", "barn" }

      ' Display the values of the array.
      Console.WriteLine("The array contains the following values:")
      For i As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
         Console.WriteLine("   [{0,2}]: {1}", i, strings(i))
      Next

      ' Search for the first occurrence of the duplicated value.
      Dim searchString As String = "the"
      Dim index As Integer = Array.IndexOf(strings, searchString)
      Console.WriteLine("The first occurrence of ""{0}"" is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in the last section of the array.
      index = Array.IndexOf(strings, searchString, 4)
      Console.WriteLine("The first occurrence of ""{0}"" between index 4 and the end is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in a section of the array.
       Dim position As Integer = index + 1
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1)
       Console.WriteLine("The first occurrence of ""{0}"" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index)
    End Sub
End Module
' The example displays the following output:
'    The array contains the following values:
'       [ 0]: the
'       [ 1]: quick
'       [ 2]: brown
'       [ 3]: fox
'       [ 4]: jumps
'       [ 5]: over
'       [ 6]: the
'       [ 7]: lazy
'       [ 8]: dog
'       [ 9]: in
'       [10]: the
'       [11]: barn
'    The first occurrence of "the" is at index 0.
'    The first occurrence of "the" between index 4 and the end is at index 6.
'    The first occurrence of "the" between index 7 and index 11 is at index 10.

설명

이 메서드 검색 인덱스에 있는 요소에서 1 차원 배열 startIndex 부터 마지막 요소입니다.This method searches a one-dimensional array from the element at index startIndex to the last element. 결정할 여부를 value 에 있는 array, 메서드를 호출 하 여 같음 비교를 수행 합니다 Equals 일치 항목을 찾을 때까지 모든 요소의 메서드.To determine whether value exists in array, the method performs an equality comparison by calling the Equals method of every element until it finds a match. 즉, 요소를 재정의 하는 경우는 Object.Equals(Object) 메서드를 재정의 하는 호출 됩니다.This means that if the element overrides the Object.Equals(Object) method, that override is called.

대부분의 배열은 하 한이 0 이므로이 메서드는 일반적으로 value을 찾을 수 없는 경우-1을 반환 합니다.Because most arrays have a lower bound of zero, this method generally returns -1 if value isn't found. 드문 경우 이지만 해당 하는 배열의 하한값 Int32.MinValue(0x80000000) 및 value 를 찾을 수 없으면이 메서드는 반환 Int32.MaxValue (0x7FFFFFFF).In the rare case that the lower bound of the array is equal to Int32.MinValue(0x80000000) and value isn't found, this method returns Int32.MaxValue (0x7FFFFFFF).

하는 경우 startIndex equals Array.Length, 메서드가-1을 반환 합니다.If startIndex equals Array.Length,the method returns -1. 하는 경우 startIndex 보다 크면 Array.Length, 메서드가 throw는 ArgumentOutOfRangeException합니다.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

이 메서드는 O (n) 작업을 여기서 n 의 요소입니다 startIndex 의 끝에 array입니다.This method is an O(n) operation, where n is the number of elements from startIndex to the end of array.

추가 정보

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. 범위는 지정한 요소 수에 대해 지정한 인덱스에서 확장됩니다.The range extends from a specified index for a specified number of elements.

public:
 static int IndexOf(Array ^ array, System::Object ^ value, int startIndex, int count);
public static int IndexOf (Array array, object value, int startIndex, int count);
static member IndexOf : Array * obj * int * int -> int

매개 변수

array
Array Array Array Array

검색할 1차원 배열입니다.The one-dimensional array to search.

value
Object Object Object Object

array에서 찾을 개체입니다.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

검색할 시작 인덱스입니다.The starting index of the search. 0은 빈 배열에서 유효합니다.0 (zero) is valid in an empty array.

count
Int32 Int32 Int32 Int32

검색할 요소의 수입니다.The number of elements to search.

반환

첫 번째 value 발생의 인덱스가 array의 인덱스 범위(startIndex ~ startIndex + count - 1)에 있으면 해당 인덱스이며 그렇지 않으면 배열의 하한에서 1을 뺀 값입니다.The index of the first occurrence of value, if it's found in the array from index startIndex to startIndex + count - 1; otherwise, the lower bound of the array minus 1.

예외

startIndexarray의 유효한 인덱스 범위를 벗어납니다.startIndex is outside the range of valid indexes for array.

또는-or- count가 0보다 작은 경우count is less than zero.

또는-or- startIndexcountarray의 올바른 섹션을 지정하지 않습니다.startIndex and count do not specify a valid section in array.

array가 다차원 배열인 경우array is multidimensional.

예제

다음 세 가지 오버 로드를 호출 하는 예제를 IndexOf 메서드 문자열 배열에서 문자열의 인덱스를 찾으려면:The example calls the following three overloads of the IndexOf method to find the index of a string in a string array:

  • IndexOf(Array, Object)를 문자열의 첫 번째 발생을 확인 하는 문자열 배열에서 "the"입니다.IndexOf(Array, Object), to determine the first occurrence of the string "the" in a string array.

  • IndexOf(Array, Object, Int32)를 문자열의 첫 번째 발생을 확인 하려면 "the" 문자열 배열의 마지막 요소에는 네 번째에 있습니다.IndexOf(Array, Object, Int32), to determine the first occurrence of the string "the" in the fourth to the last elements of a string array.

  • IndexOf(Array, Object, Int32, Int32)를 문자열의 첫 번째 발생을 확인 하려면 문자열에서 "the" 배열에서 마지막으로 성공한 일치 항목을 배열의 끝에 다음에 나오는 요소가 있습니다.IndexOf(Array, Object, Int32, Int32), to determine the first occurrence of the string "the" in a string array from the element that follows the last successful match to the end of the array. 값을 확인 하는 count 인수를 배열의 시작 인덱스에서 상한 빼고 하나를 추가 합니다.To determine the value of the count argument, it subtracts the upper bound of the array from the starting index and adds one.

using namespace System;

void main()
{
   // Create a string array with 3 elements having the same value.
   array<String^>^ strings = { "the", "quick", "brown", "fox",
                               "jumps", "over", "the", "lazy", "dog",
                               "in", "the", "barn" };

   // Display the elements of the array.
   Console::WriteLine("The array contains the following values:");
   for (int i = strings->GetLowerBound(0); i <= strings->GetUpperBound(0); i++)
      Console::WriteLine("   [{0,2}]: {1}", i, strings[i]);
      
   // Search for the first occurrence of the duplicated value.
   String^ searchString =  "the";
   int index = Array::IndexOf(strings, searchString);
   Console::WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in the last section of the array.
   index = Array::IndexOf( strings, searchString, 4);
   Console::WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in a section of the array.
   int position = index + 1;
   index = Array::IndexOf(strings, searchString, position, strings->GetUpperBound(0) - position + 1);
   Console::WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                      searchString, position, strings->GetUpperBound(0), index);
}
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
using System;

public class Example
{
    public static void Main()
    {
       // Create a string array with 3 elements having the same value.
       String[] strings = { "the", "quick", "brown", "fox", "jumps",
                            "over", "the", "lazy", "dog", "in", "the",
                            "barn" };

       // Display the elements of the array.
       Console.WriteLine("The array contains the following values:");
       for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
          Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);

       // Search for the first occurrence of the duplicated value.
       String searchString = "the";
       int index = Array.IndexOf(strings, searchString);
       Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in the last section of the array.
       index = Array.IndexOf(strings, searchString, 4);
       Console.WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in a section of the array.
       int position = index + 1;
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
       Console.WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index);
    }
 }
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
Public Module Example
   Public Sub Main()
      ' Create a string array with 3 elements having the same value.
      Dim strings() As String = { "the", "quick", "brown", "fox",
                                  "jumps", "over", "the", "lazy",
                                  "dog", "in", "the", "barn" }

      ' Display the values of the array.
      Console.WriteLine("The array contains the following values:")
      For i As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
         Console.WriteLine("   [{0,2}]: {1}", i, strings(i))
      Next

      ' Search for the first occurrence of the duplicated value.
      Dim searchString As String = "the"
      Dim index As Integer = Array.IndexOf(strings, searchString)
      Console.WriteLine("The first occurrence of ""{0}"" is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in the last section of the array.
      index = Array.IndexOf(strings, searchString, 4)
      Console.WriteLine("The first occurrence of ""{0}"" between index 4 and the end is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in a section of the array.
       Dim position As Integer = index + 1
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1)
       Console.WriteLine("The first occurrence of ""{0}"" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index)
    End Sub
End Module
' The example displays the following output:
'    The array contains the following values:
'       [ 0]: the
'       [ 1]: quick
'       [ 2]: brown
'       [ 3]: fox
'       [ 4]: jumps
'       [ 5]: over
'       [ 6]: the
'       [ 7]: lazy
'       [ 8]: dog
'       [ 9]: in
'       [10]: the
'       [11]: barn
'    The first occurrence of "the" is at index 0.
'    The first occurrence of "the" between index 4 and the end is at index 6.
'    The first occurrence of "the" between index 7 and index 11 is at index 10.

설명

이 메서드는 1 차원 배열의 요소에서-0을 startIndex을 더한 값 count이 0 보다 크면 @no__t 1을 @no__t.This method searches the elements of a one-dimensional array from startIndex to startIndex plus count minus 1, if count is greater than 0. 결정할 여부를 value 에 있는 array, 메서드를 호출 하 여 같음 비교를 수행 합니다 Equals 일치 항목을 찾을 때까지 모든 요소의 메서드.To determine whether value exists in array, the method performs an equality comparison by calling the Equals method of every element until it finds a match. 즉, 요소를 재정의 하는 경우는 Object.Equals 메서드를 재정의 하는 호출 됩니다.This means that if the element overrides the Object.Equals method, that override is called.

대부분의 배열은 하 한이 0 이므로이 메서드는 일반적으로 value을 찾을 수 없는 경우-1을 반환 합니다.Because most arrays have a lower bound of zero, this method generally returns -1 when value isn't found. 드문 경우 이지만 해당 하는 배열의 하한값 Int32.MinValue (0x80000000) 및 value 를 찾을 수 없으면이 메서드는 반환 Int32.MaxValue (0x7FFFFFFF).In the rare case that the lower bound of the array is equal to Int32.MinValue (0x80000000) and value isn't found, this method returns Int32.MaxValue (0x7FFFFFFF).

하는 경우 startindex equals Array.Length, 메서드가-1을 반환 합니다.If startindex equals Array.Length, the method returns -1. 하는 경우 startIndex 보다 크면 Array.Length, 메서드가 throw는 ArgumentOutOfRangeException합니다.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

이 메서드는 O (n) 작업, 여기서 ncount합니다.This method is an O(n) operation, where n is count.

추가 정보

IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. 범위는 지정한 요소 수에 대해 지정한 인덱스에서 확장됩니다.The range extends from a specified index for a specified number of elements.

public:
generic <typename T>
 static int IndexOf(cli::array <T> ^ array, T value, int startIndex, int count);
public static int IndexOf<T> (T[] array, T value, int startIndex, int count);
static member IndexOf : 'T[] * 'T * int * int -> int
Public Shared Function IndexOf(Of T) (array As T(), value As T, startIndex As Integer, count As Integer) As Integer

형식 매개 변수

T

배열 요소의 형식입니다.The type of the elements of the array.

매개 변수

array
T[]

검색할 1차원(인덱스는 0부터 시작) 배열입니다.The one-dimensional, zero-based array to search.

value
T T T T

array에서 찾을 개체입니다.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

검색의 0부터 시작하는 인덱스입니다.The zero-based starting index of the search. 0은 빈 배열에서 유효합니다.0 (zero) is valid in an empty array.

count
Int32 Int32 Int32 Int32

검색할 섹션에 있는 요소 수입니다.The number of elements in the section to search.

반환

startIndex부터 시작하여 count에 지정된 수의 요소를 포함하는 array의 요소 범위 내에서 value가 있으면 처음으로 나타나는 개체의 인덱스(0부터 시작)이고, 그렇지 않으면 -1입니다.The zero-based index of the first occurrence of value within the range of elements in array that starts at startIndex and contains the number of elements specified in count, if found; otherwise, -1.

예외

startIndexarray의 유효한 인덱스 범위를 벗어납니다.startIndex is outside the range of valid indexes for array.

또는-or- count가 0보다 작은 경우count is less than zero.

또는-or- startIndexcountarray의 올바른 섹션을 지정하지 않습니다.startIndex and count do not specify a valid section in array.

예제

다음 예제에서는 모든 세 가지 제네릭 오버 로드는 IndexOf 메서드.The following example demonstrates all three generic overloads of the IndexOf method. 문자열의 배열 인덱스 0과 인덱스 위치 5에 두 번 나타나는 하나의 항목으로 만들어집니다.An array of strings is created, with one entry that appears twice, at index location 0 and index location 5. IndexOf<T>(T[], T) 메서드 오버 로드는 배열부터에서 검색 하 고 문자열의 첫 번째 항목을 찾습니다.The IndexOf<T>(T[], T) method overload searches the array from the beginning, and finds the first occurrence of the string. IndexOf<T>(T[], T, Int32) 메서드 오버 로드 3 인덱스 위치를 사용 하 여 시작 하 여 배열 및 배열 끝까지 계속 검색 하는 데 사용 되 고 문자열의 두 번째 항목을 찾습니다.The IndexOf<T>(T[], T, Int32) method overload is used to search the array beginning with index location 3 and continuing to the end of the array, and finds the second occurrence of the string. 마지막으로 IndexOf<T>(T[], T, Int32, Int32) 메서드 오버 로드를 사용 하는 다양 한 두 인덱스 위치에서 시작 하는 두 개의 항목을 검색할; 범위에 검색 문자열의 인스턴스인 때문에-1을 반환 합니다.Finally, the IndexOf<T>(T[], T, Int32, Int32) method overload is used to search a range of two entries, beginning at index location two; it returns -1 because there are no instances of the search string in that range.

using namespace System;

void main()
{
    array<String^>^ dinosaurs = { "Tyrannosaurus", 
        "Amargasaurus",
        "Mamenchisaurus",
        "Brachiosaurus",
        "Deinonychus",
        "Tyrannosaurus",
        "Compsognathus" };

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus"));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 3));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Tyrannosaurus",
            "Amargasaurus",
            "Mamenchisaurus",
            "Brachiosaurus",
            "Deinonychus",
            "Tyrannosaurus",
            "Compsognathus" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus"));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 2, 2): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1

설명

이 메서드는 1 차원 배열의 요소에서-0을 startIndex을 더한 값 count이 0 보다 크면 @no__t 1을 @no__t.This method searches the elements of a one-dimensional array from startIndex to startIndex plus count minus 1, if count is greater than 0. 결정할 여부를 value 에 있는 array, 메서드를 호출 하 여 같음 비교를 수행 합니다 T.Equals 모든 요소에 대해 메서드.To determine whether value exists in array, the method performs an equality comparison by calling the T.Equals method on every element. T 재정의 Equals 메서드를 재정의 하는 호출 됩니다.This means that if T overrides the Equals method, that override is called.

하는 경우 startIndex equals Array.Length, 메서드가-1을 반환 합니다.If startIndex equals Array.Length, the method returns -1. 하는 경우 startIndex 보다 크면 Array.Length, 메서드가 throw는 ArgumentOutOfRangeException합니다.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

이 메서드는 O (n) 작업, 여기서 ncount합니다.This method is an O(n) operation, where n is count.

추가 정보

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

지정한 개체를 검색하여 1차원 배열에서 처음 검색된 개체의 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

public:
generic <typename T>
 static int IndexOf(cli::array <T> ^ array, T value);
public static int IndexOf<T> (T[] array, T value);
static member IndexOf : 'T[] * 'T -> int
Public Shared Function IndexOf(Of T) (array As T(), value As T) As Integer

형식 매개 변수

T

배열 요소의 형식입니다.The type of the elements of the array.

매개 변수

array
T[]

검색할 1차원(인덱스는 0부터 시작) 배열입니다.The one-dimensional, zero-based array to search.

value
T T T T

array에서 찾을 개체입니다.The object to locate in array.

반환

전체 array에서 value가 있으면 처음으로 나타나는 개체의 인덱스(0부터 시작)이고, 그렇지 않으면 -1입니다.The zero-based index of the first occurrence of value in the entire array, if found; otherwise, -1.

예외

예제

다음 예제에서는 모든 세 가지 제네릭 오버 로드는 IndexOf 메서드.The following example demonstrates all three generic overloads of the IndexOf method. 문자열의 배열 인덱스 0과 인덱스 위치 5에 두 번 나타나는 하나의 항목으로 만들어집니다.An array of strings is created, with one entry that appears twice, at index location 0 and index location 5. IndexOf<T>(T[], T) 메서드 오버 로드는 배열부터에서 검색 하 고 문자열의 첫 번째 항목을 찾습니다.The IndexOf<T>(T[], T) method overload searches the array from the beginning, and finds the first occurrence of the string. IndexOf<T>(T[], T, Int32) 메서드 오버 로드 3 인덱스 위치를 사용 하 여 시작 하 여 배열 및 배열 끝까지 계속 검색 하는 데 사용 되 고 문자열의 두 번째 항목을 찾습니다.The IndexOf<T>(T[], T, Int32) method overload is used to search the array beginning with index location 3 and continuing to the end of the array, and finds the second occurrence of the string. 마지막으로 IndexOf<T>(T[], T, Int32, Int32) 메서드 오버 로드를 사용 하는 다양 한 두 인덱스 위치에서 시작 하는 두 개의 항목을 검색할; 범위에 검색 문자열의 인스턴스인 때문에-1을 반환 합니다.Finally, the IndexOf<T>(T[], T, Int32, Int32) method overload is used to search a range of two entries, beginning at index location two; it returns -1 because there are no instances of the search string in that range.

using namespace System;

void main()
{
    array<String^>^ dinosaurs = { "Tyrannosaurus", 
        "Amargasaurus",
        "Mamenchisaurus",
        "Brachiosaurus",
        "Deinonychus",
        "Tyrannosaurus",
        "Compsognathus" };

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus"));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 3));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Tyrannosaurus",
            "Amargasaurus",
            "Mamenchisaurus",
            "Brachiosaurus",
            "Deinonychus",
            "Tyrannosaurus",
            "Compsognathus" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus"));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 2, 2): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1

설명

이 메서드 검색의 1 차원 배열의 모든 요소 value합니다.This method searches all the elements of a one-dimensional array for value. 결정할 여부를 value 에 있는 array, 메서드를 호출 하 여 같음 비교를 수행 합니다 T.Equals 모든 요소에 대해 메서드.To determine whether value exists in array, the method performs an equality comparison by calling the T.Equals method on every element. T 재정의 Equals 메서드를 재정의 하는 호출 됩니다.This means that if T overrides the Equals method, that override is called.

이 메서드는 O (n) 작업을 여기서 nLengtharray합니다.This method is an O(n) operation, where n is the Length of array.

추가 정보

IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. 범위는 지정한 인덱스에서 배열의 끝까지 확장됩니다.The range extends from a specified index to the end of the array.

public:
generic <typename T>
 static int IndexOf(cli::array <T> ^ array, T value, int startIndex);
public static int IndexOf<T> (T[] array, T value, int startIndex);
static member IndexOf : 'T[] * 'T * int -> int
Public Shared Function IndexOf(Of T) (array As T(), value As T, startIndex As Integer) As Integer

형식 매개 변수

T

배열 요소의 형식입니다.The type of the elements of the array.

매개 변수

array
T[]

검색할 1차원(인덱스는 0부터 시작) 배열입니다.The one-dimensional, zero-based array to search.

value
T T T T

array에서 찾을 개체입니다.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

검색의 0부터 시작하는 인덱스입니다.The zero-based starting index of the search. 0은 빈 배열에서 유효합니다.0 (zero) is valid in an empty array.

반환

startIndex에서 마지막 요소까지 확장되는 array의 요소 범위 내에서 value가 있으면 처음으로 나타나는 개체의 인덱스(0부터 시작)이고, 그렇지 않으면 -1입니다.The zero-based index of the first occurrence of value within the range of elements in array that extends from startIndex to the last element, if found; otherwise, -1.

예외

startIndexarray의 유효한 인덱스 범위를 벗어납니다.startIndex is outside the range of valid indexes for array.

예제

다음 예제에서는 모든 세 가지 제네릭 오버 로드는 IndexOf 메서드.The following example demonstrates all three generic overloads of the IndexOf method. 문자열의 배열 인덱스 0과 인덱스 위치 5에 두 번 나타나는 하나의 항목으로 만들어집니다.An array of strings is created, with one entry that appears twice, at index location 0 and index location 5. IndexOf<T>(T[], T) 메서드 오버 로드는 배열부터에서 검색 하 고 문자열의 첫 번째 항목을 찾습니다.The IndexOf<T>(T[], T) method overload searches the array from the beginning, and finds the first occurrence of the string. IndexOf<T>(T[], T, Int32) 메서드 오버 로드 3 인덱스 위치를 사용 하 여 시작 하 여 배열 및 배열 끝까지 계속 검색 하는 데 사용 되 고 문자열의 두 번째 항목을 찾습니다.The IndexOf<T>(T[], T, Int32) method overload is used to search the array beginning with index location 3 and continuing to the end of the array, and finds the second occurrence of the string. 마지막으로 IndexOf<T>(T[], T, Int32, Int32) 메서드 오버 로드를 사용 하는 다양 한 두 인덱스 위치에서 시작 하는 두 개의 항목을 검색할; 범위에 검색 문자열의 인스턴스인 때문에-1을 반환 합니다.Finally, the IndexOf<T>(T[], T, Int32, Int32) method overload is used to search a range of two entries, beginning at index location two; it returns -1 because there are no instances of the search string in that range.

using namespace System;

void main()
{
    array<String^>^ dinosaurs = { "Tyrannosaurus", 
        "Amargasaurus",
        "Mamenchisaurus",
        "Brachiosaurus",
        "Deinonychus",
        "Tyrannosaurus",
        "Compsognathus" };

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus"));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 3));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Tyrannosaurus",
            "Amargasaurus",
            "Mamenchisaurus",
            "Brachiosaurus",
            "Deinonychus",
            "Tyrannosaurus",
            "Compsognathus" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus"));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 2, 2): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1

설명

이 메서드는 1 차원 배열에 있는 요소에서 검색 startIndex 배열의 끝에 있습니다.This method searches a one-dimensional array from the element at startIndex to the end of the array. 결정할 여부를 value 에 있는 array, 메서드를 호출 하 여 같음 비교를 수행 합니다 T.Equals 모든 요소에 대해 메서드.To determine whether value exists in array, the method performs an equality comparison by calling the T.Equals method on every element. T 재정의 Equals 메서드를 재정의 하는 호출 됩니다.This means that if T overrides the Equals method, that override is called.

경우 startIndex equals Length, 메서드가 반환-1.If startIndex 보다 크면 Array.Length, 메서드에서 throw는 ArgumentOutOfRangeException합니다.If startIndex equals Length,the method returns -1.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

이 메서드는 O (n) 작업을 여기서 n 의 요소입니다 startIndex 의 끝에 array입니다.This method is an O(n) operation, where n is the number of elements from startIndex to the end of array.

추가 정보

적용 대상