Array.LastIndexOf Méthode

Source:

Array.cs

Source:

Array.cs

Source:

Array.cs

public static int LastIndexOf (Array array, object value);

public static int LastIndexOf (Array array, object? value);

Paramètres

Retours

Index de la dernière occurrence de value dans l’ensemble de la array, s’il est trouvé ; sinon, la limite inférieure du tableau moins 1.

Exceptions

Exemples

L’exemple de code suivant montre comment déterminer l’index de la dernière occurrence d’un élément spécifié dans un tableau.

// Creates and initializes a new Array with three elements of the same value.
Array myArray=Array.CreateInstance( typeof(string), 12 );
myArray.SetValue( "the", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
myArray.SetValue( "in", 9 );
myArray.SetValue( "the", 10 );
myArray.SetValue( "barn", 11 );

// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintIndexAndValues( myArray );

// Searches for the last occurrence of the duplicated value.
string myString = "the";
int myIndex = Array.LastIndexOf( myArray, myString );
Console.WriteLine( "The last occurrence of \"{0}\" is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in the first section of the Array.
myIndex = Array.LastIndexOf( myArray, myString, 8 );
Console.WriteLine( "The last occurrence of \"{0}\" between the start and index 8 is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
myIndex = Array.LastIndexOf( myArray, myString, 10, 6 );
Console.WriteLine( "The last occurrence of \"{0}\" between index 5 and index 10 is at index {1}.", myString, myIndex );

void PrintIndexAndValues( Array anArray )  {
   for ( int i = anArray.GetLowerBound(0); i <= anArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, anArray.GetValue( i ) );
}

/*
This code produces 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 last occurrence of "the" is at index 10.
The last occurrence of "the" between the start and index 8 is at index 6.
The last occurrence of "the" between index 5 and index 10 is at index 10.
*/

Remarques

Le Array unidimensionnel est recherché en arrière à partir du dernier élément et se termine au premier élément.

Les éléments sont comparés à la valeur spécifiée à l’aide de la méthode Object.Equals. Si le type d’élément est un type nontrinsique (défini par l’utilisateur), l’implémentation Equals de ce type est utilisée.

Étant donné que la plupart des tableaux ont une limite inférieure de zéro, cette méthode retourne généralement -1 lorsque value est introuvable. Dans les rares cas où la limite inférieure du tableau est égale à Int32.MinValue et value est introuvable, cette méthode retourne Int32.MaxValue, qui est System.Int32.MinValue - 1.

Cette méthode est une opération O(n), où n est la Length de array.

Dans .NET Framework 2.0 et versions ultérieures, cette méthode utilise les méthodes Equals et CompareTo de l'Array pour déterminer si la Object spécifiée par le paramètre value existe. Dans les versions antérieures de .NET Framework, cette détermination a été effectuée à l’aide des méthodes de Equals et de CompareTo des valueObject elle-même.

CompareTo méthodes du paramètre item sur les objets de la collection.

Voir aussi

• IndexOf
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux

Source:

Array.cs

Source:

Array.cs

Source:

Array.cs

public static int LastIndexOf (Array array, object value, int startIndex);

public static int LastIndexOf (Array array, object? value, int startIndex);

Paramètres

Retours

Index de la dernière occurrence de value dans la plage d’éléments de array qui s’étend du premier élément à startIndex, s’il est trouvé ; sinon, la limite inférieure du tableau moins 1.

Exceptions

Exemples

L’exemple de code suivant montre comment déterminer l’index de la dernière occurrence d’un élément spécifié dans un tableau.

// Creates and initializes a new Array with three elements of the same value.
Array myArray=Array.CreateInstance( typeof(string), 12 );
myArray.SetValue( "the", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
myArray.SetValue( "in", 9 );
myArray.SetValue( "the", 10 );
myArray.SetValue( "barn", 11 );

// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintIndexAndValues( myArray );

// Searches for the last occurrence of the duplicated value.
string myString = "the";
int myIndex = Array.LastIndexOf( myArray, myString );
Console.WriteLine( "The last occurrence of \"{0}\" is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in the first section of the Array.
myIndex = Array.LastIndexOf( myArray, myString, 8 );
Console.WriteLine( "The last occurrence of \"{0}\" between the start and index 8 is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
myIndex = Array.LastIndexOf( myArray, myString, 10, 6 );
Console.WriteLine( "The last occurrence of \"{0}\" between index 5 and index 10 is at index {1}.", myString, myIndex );

void PrintIndexAndValues( Array anArray )  {
   for ( int i = anArray.GetLowerBound(0); i <= anArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, anArray.GetValue( i ) );
}

/*
This code produces 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 last occurrence of "the" is at index 10.
The last occurrence of "the" between the start and index 8 is at index 6.
The last occurrence of "the" between index 5 and index 10 is at index 10.
*/

Remarques

Le Array unidimensionnel est recherché vers l’arrière à partir de startIndex et se termine au premier élément.

Les éléments sont comparés à la valeur spécifiée à l’aide de la méthode Object.Equals. Si le type d’élément est un type nontrinsique (défini par l’utilisateur), l’implémentation Equals de ce type est utilisée.

Étant donné que la plupart des tableaux ont une limite inférieure de zéro, cette méthode retourne généralement -1 lorsque value est introuvable. Dans les rares cas où la limite inférieure du tableau est égale à Int32.MinValue et value est introuvable, cette méthode retourne Int32.MaxValue, qui est System.Int32.MinValue - 1.

Cette méthode est une opération O(n), où n est le nombre d’éléments du début de array à startIndex.

Dans .NET Framework 2.0 et versions ultérieures, cette méthode utilise les méthodes Equals et CompareTo de l'Array pour déterminer si la Object spécifiée par le paramètre value existe. Dans les versions antérieures de .NET Framework, cette détermination a été effectuée à l’aide des méthodes de Equals et de CompareTo des valueObject elle-même.

Voir aussi

• IndexOf
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux

Source:

Array.cs

Source:

Array.cs

Source:

Array.cs

public static int LastIndexOf (Array array, object value, int startIndex, int count);

public static int LastIndexOf (Array array, object? value, int startIndex, int count);

Paramètres

Retours

Index de la dernière occurrence de value dans la plage d’éléments de array qui contient le nombre d’éléments spécifiés dans count et se termine à startIndex, le cas échéant ; sinon, la limite inférieure du tableau moins 1.

Exceptions

Exemples

L’exemple de code suivant montre comment déterminer l’index de la dernière occurrence d’un élément spécifié dans un tableau. Notez que la méthode LastIndexOf est une recherche descendante ; par conséquent, count doit être inférieur ou égal à (startIndex moins la limite inférieure du tableau plus 1).

// Creates and initializes a new Array with three elements of the same value.
Array myArray=Array.CreateInstance( typeof(string), 12 );
myArray.SetValue( "the", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
myArray.SetValue( "in", 9 );
myArray.SetValue( "the", 10 );
myArray.SetValue( "barn", 11 );

// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintIndexAndValues( myArray );

// Searches for the last occurrence of the duplicated value.
string myString = "the";
int myIndex = Array.LastIndexOf( myArray, myString );
Console.WriteLine( "The last occurrence of \"{0}\" is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in the first section of the Array.
myIndex = Array.LastIndexOf( myArray, myString, 8 );
Console.WriteLine( "The last occurrence of \"{0}\" between the start and index 8 is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
myIndex = Array.LastIndexOf( myArray, myString, 10, 6 );
Console.WriteLine( "The last occurrence of \"{0}\" between index 5 and index 10 is at index {1}.", myString, myIndex );

void PrintIndexAndValues( Array anArray )  {
   for ( int i = anArray.GetLowerBound(0); i <= anArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, anArray.GetValue( i ) );
}

/*
This code produces 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 last occurrence of "the" is at index 10.
The last occurrence of "the" between the start and index 8 is at index 6.
The last occurrence of "the" between index 5 and index 10 is at index 10.
*/

Remarques

Le Array unidimensionnel est recherché à l’arrière à partir de startIndex et se termine à startIndex moins count plus 1, si count est supérieur à 0.

Les éléments sont comparés à la valeur spécifiée à l’aide de la méthode Object.Equals. Si le type d’élément est un type nonintrinsique (défini par l’utilisateur), l’implémentationEquals de ce type est utilisée.

Étant donné que la plupart des tableaux ont une limite inférieure de zéro, cette méthode retourne généralement -1 lorsque value est introuvable. Dans les rares cas où la limite inférieure du tableau est égale à Int32.MinValue et value est introuvable, cette méthode retourne Int32.MaxValue, qui est System.Int32.MinValue - 1.

Cette méthode est une opération O(n), où n est count.

Dans .NET Framework 2.0 et versions ultérieures, cette méthode utilise les méthodes Equals et CompareTo de l'Array pour déterminer si la Object spécifiée par le paramètre value existe. Dans les versions antérieures de .NET Framework, cette détermination a été effectuée à l’aide des méthodes de Equals et de CompareTo des valueObject elle-même.

Voir aussi

• IndexOf
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux

Source:

Array.cs

Source:

Array.cs

Source:

Array.cs

public static int LastIndexOf<T> (T[] array, T value);

Paramètres de type

Paramètres

Retours

Index de base zéro de la dernière occurrence de value dans l’ensemble du array, s’il est trouvé ; sinon, -1.

Exceptions

Exemples

L’exemple de code suivant illustre les trois surcharges génériques de la méthode LastIndexOf. Un tableau de chaînes est créé, avec une entrée qui apparaît deux fois, à l’emplacement d’index 0 et à l’emplacement d’index 5. La surcharge de méthode LastIndexOf<T>(T[], T) recherche l’intégralité du tableau à partir de la fin et recherche la deuxième occurrence de la chaîne. La surcharge de méthode LastIndexOf<T>(T[], T, Int32) est utilisée pour rechercher le tableau vers l’arrière à partir de l’emplacement d’index 3 et passer au début du tableau, et recherche la première occurrence de la chaîne. Enfin, la surcharge de méthode LastIndexOf<T>(T[], T, Int32, Int32) est utilisée pour rechercher une plage de quatre entrées, en commençant à l’emplacement d’index 4 et en s’étendant vers l’arrière (autrement dit, il recherche les éléments aux emplacements 4, 3, 2 et 1) ; cette recherche retourne -1 car il n’existe aucune instance de la chaîne de recherche dans cette plage.

string[] dinosaurs = { "Tyrannosaurus",
    "Amargasaurus",
    "Mamenchisaurus",
    "Brachiosaurus",
    "Deinonychus",
    "Tyrannosaurus",
    "Compsognathus" };

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

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

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

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

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1
*/

Remarques

Le Array est recherché vers l’arrière à partir du dernier élément et se termine au premier élément.

Les éléments sont comparés à la valeur spécifiée à l’aide de la méthode Object.Equals. Si le type d’élément est un type nontrinsique (défini par l’utilisateur), l’implémentation Equals de ce type est utilisée.

Cette méthode est une opération O(n), où n est la Length de array.

Voir aussi

• IndexOf
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux

Source:

Array.cs

Source:

Array.cs

Source:

Array.cs

public static int LastIndexOf<T> (T[] array, T value, int startIndex);

Paramètres de type

Paramètres

Retours

Index de base zéro de la dernière occurrence de value dans la plage d’éléments de array qui s’étend du premier élément à startIndex, s’il est trouvé ; sinon, -1.

Exceptions

Exemples

L’exemple de code suivant illustre les trois surcharges génériques de la méthode LastIndexOf. Un tableau de chaînes est créé, avec une entrée qui apparaît deux fois, à l’emplacement d’index 0 et à l’emplacement d’index 5. La surcharge de méthode LastIndexOf<T>(T[], T) recherche l’intégralité du tableau à partir de la fin et recherche la deuxième occurrence de la chaîne. La surcharge de méthode LastIndexOf<T>(T[], T, Int32) est utilisée pour rechercher le tableau vers l’arrière à partir de l’emplacement d’index 3 et passer au début du tableau, et recherche la première occurrence de la chaîne. Enfin, la surcharge de méthode LastIndexOf<T>(T[], T, Int32, Int32) est utilisée pour rechercher une plage de quatre entrées, en commençant à l’emplacement d’index 4 et en s’étendant vers l’arrière (autrement dit, il recherche les éléments aux emplacements 4, 3, 2 et 1) ; cette recherche retourne -1 car il n’existe aucune instance de la chaîne de recherche dans cette plage.

string[] dinosaurs = { "Tyrannosaurus",
    "Amargasaurus",
    "Mamenchisaurus",
    "Brachiosaurus",
    "Deinonychus",
    "Tyrannosaurus",
    "Compsognathus" };

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

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

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

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

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1
*/

Remarques

Le Array est recherché à l’arrière à partir de startIndex et se termine au premier élément.

Les éléments sont comparés à la valeur spécifiée à l’aide de la méthode Object.Equals. Si le type d’élément est un type nontrinsique (défini par l’utilisateur), l’implémentation Equals de ce type est utilisée.

Cette méthode est une opération O(n), où n est le nombre d’éléments du début de array à startIndex.

Voir aussi

• IndexOf
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux

Source:

Array.cs

Source:

Array.cs

Source:

Array.cs

public static int LastIndexOf<T> (T[] array, T value, int startIndex, int count);

Paramètres de type

Paramètres

Retours

Index de base zéro de la dernière occurrence de value dans la plage d’éléments de array qui contient le nombre d’éléments spécifiés dans count et se termine à startIndex, le cas échéant ; sinon, -1.

Exceptions

Exemples

L’exemple de code suivant illustre les trois surcharges génériques de la méthode LastIndexOf. Un tableau de chaînes est créé, avec une entrée qui apparaît deux fois, à l’emplacement d’index 0 et à l’emplacement d’index 5. La surcharge de méthode LastIndexOf<T>(T[], T) recherche l’intégralité du tableau à partir de la fin et recherche la deuxième occurrence de la chaîne. La surcharge de méthode LastIndexOf<T>(T[], T, Int32) est utilisée pour rechercher le tableau vers l’arrière à partir de l’emplacement d’index 3 et passer au début du tableau, et recherche la première occurrence de la chaîne. Enfin, la surcharge de méthode LastIndexOf<T>(T[], T, Int32, Int32) est utilisée pour rechercher une plage de quatre entrées, en commençant à l’emplacement d’index 4 et en s’étendant vers l’arrière (autrement dit, il recherche les éléments aux emplacements 4, 3, 2 et 1) ; cette recherche retourne -1 car il n’existe aucune instance de la chaîne de recherche dans cette plage.

string[] dinosaurs = { "Tyrannosaurus",
    "Amargasaurus",
    "Mamenchisaurus",
    "Brachiosaurus",
    "Deinonychus",
    "Tyrannosaurus",
    "Compsognathus" };

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

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

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

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

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1
*/

Remarques

Le Array est recherché en arrière à partir de startIndex et se terminant à startIndex moins count plus 1, si count est supérieur à 0.

Les éléments sont comparés à la valeur spécifiée à l’aide de la méthode Object.Equals. Si le type d’élément est un type nontrinsique (défini par l’utilisateur), l’implémentation Equals de ce type est utilisée.

Cette méthode est une opération O(n), où n est count.

Voir aussi

• IndexOf
• effectuer des opérations de chaîne Culture-Insensitive dans des tableaux