Guide : Trier un Tableau en VB.Net
Trier un tableau en VB.Net consiste à organiser ses éléments dans un ordre spécifique, tel que croissant, décroissant ou selon une condition particulière. VB.Net fournit des outils puissants pour accomplir cela, notamment avec la classe Array
.
1. Trier un Tableau de Base
Méthode : Array.Sort
La méthode Array.Sort
trie les éléments d’un tableau en ordre croissant par défaut.
Exemple : Trier des nombres croissants
Dim nombres() As Integer = {5, 3, 8, 1, 9}
Array.Sort(nombres)
For Each n As Integer In nombres
Console.WriteLine(n)
Next
Résultat :
1
3
5
8
9
Exemple : Trier des chaînes (ordre alphabétique)
Dim fruits() As String = {"Banane", "Pomme", "Orange", "Cerise"}
Array.Sort(fruits)
For Each fruit As String In fruits
Console.WriteLine(fruit)
Next
Résultat :
Banane
Cerise
Orange
Pomme
2. Trier un Tableau en Ordre Décroissant
Pour trier un tableau en ordre décroissant, utilisez la méthode Array.Sort
suivie de Array.Reverse
.
Exemple :
Dim nombres() As Integer = {5, 3, 8, 1, 9}
Array.Sort(nombres)
Array.Reverse(nombres)
For Each n As Integer In nombres
Console.WriteLine(n)
Next
Résultat :
9
8
5
3
1
3. Trier un Tableau d’Objets
Pour trier un tableau d’objets, utilisez Array.Sort
avec une fonction de comparaison personnalisée ou une expression Lambda.
Exemple : Trier un tableau de classes
Classe Personne
:
Public Class Personne
Public Property Nom As String
Public Property Age As Integer
End Class
Code pour trier par âge :
Dim personnes() As Personne = {
New Personne With {.Nom = "Jean", .Age = 30},
New Personne With {.Nom = "Marie", .Age = 25},
New Personne With {.Nom = "Paul", .Age = 40}
}
Array.Sort(personnes, Function(p1, p2) p1.Age.CompareTo(p2.Age))
For Each personne As Personne In personnes
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
Résultat :
Nom : Marie, Âge : 25
Nom : Jean, Âge : 30
Nom : Paul, Âge : 40
4. Trier avec LINQ
LINQ (Language Integrated Query) offre une manière plus expressive de trier des tableaux.
Exemple : Trier des nombres
Imports System.Linq
Dim nombres() As Integer = {5, 3, 8, 1, 9}
Dim nombresTries = nombres.OrderBy(Function(n) n).ToArray()
For Each n As Integer In nombresTries
Console.WriteLine(n)
Next
Exemple : Trier des objets
Imports System.Linq
Dim personnes() As Personne = {
New Personne With {.Nom = "Jean", .Age = 30},
New Personne With {.Nom = "Marie", .Age = 25},
New Personne With {.Nom = "Paul", .Age = 40}
}
Dim personnesTries = personnes.OrderBy(Function(p) p.Age).ToArray()
For Each personne As Personne In personnesTries
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
5. Trier Partiellement un Tableau
Pour trier une partie spécifique d’un tableau, utilisez la méthode surchargée de Array.Sort
.
Exemple : Trier une portion d’un tableau
Dim nombres() As Integer = {5, 3, 8, 1, 9}
Array.Sort(nombres, 1, 3) ' Trie uniquement les éléments de l’index 1 à 3
For Each n As Integer In nombres
Console.WriteLine(n)
Next
Résultat :
5
1
3
8
9
6. Trier avec Une Fonction Personnalisée
Si vous souhaitez trier selon une logique complexe, utilisez IComparer
ou une fonction de comparaison.
Exemple : Trier par longueur de chaîne
Dim fruits() As String = {"Banane", "Pomme", "Orange", "Cerise"}
Array.Sort(fruits, Function(x, y) x.Length.CompareTo(y.Length))
For Each fruit As String In fruits
Console.WriteLine(fruit)
Next
Résultat :
Pomme
Cerise
Banane
Orange
7. Avantages et Limites
Avantages :
- Flexibilité :
Array.Sort
et LINQ permettent de trier selon différentes logiques. - Performance : Tri rapide et optimisé pour des tableaux de grande taille.
Limites :
- Immuabilité :
Array.Sort
modifie le tableau original. Pour conserver le tableau d’origine, utilisez LINQ pour retourner un tableau trié.
8. Exemple Complet : Trier Différents Types de Tableaux
Voici un programme complet qui montre différents types de tris.
Module Module1
Sub Main()
' Trier un tableau d’entiers
Dim nombres() As Integer = {5, 3, 8, 1, 9}
Array.Sort(nombres)
Console.WriteLine("Nombres triés croissants : " & String.Join(", ", nombres))
' Trier un tableau de chaînes
Dim fruits() As String = {"Banane", "Pomme", "Orange", "Cerise"}
Array.Sort(fruits)
Console.WriteLine("Fruits triés alphabétiquement : " & String.Join(", ", fruits))
' Trier un tableau d’objets
Dim personnes() As Personne = {
New Personne With {.Nom = "Jean", .Age = 30},
New Personne With {.Nom = "Marie", .Age = 25},
New Personne With {.Nom = "Paul", .Age = 40}
}
Array.Sort(personnes, Function(p1, p2) p1.Age.CompareTo(p2.Age))
Console.WriteLine("Personnes triées par âge :")
For Each personne As Personne In personnes
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
Console.ReadLine()
End Sub
Public Class Personne
Public Property Nom As String
Public Property Age As Integer
End Class
End Module
Résumé
Méthode | Description |
---|---|
Array.Sort | Trie un tableau en ordre croissant. |
Array.Reverse | Inverse l’ordre des éléments après un tri. |
LINQ OrderBy | Trie en retournant une nouvelle version du tableau. |
Array.Sort avec Comparaison | Permet un tri personnalisé basé sur une logique définie. |
Comment Trier un Tableau avec LINQ en VB.Net
LINQ (Language Integrated Query) permet de trier facilement des tableaux en VB.Net en utilisant des méthodes comme OrderBy
, OrderByDescending
, et leurs variantes. Ces méthodes sont idéales car elles ne modifient pas le tableau d’origine, mais renvoient une nouvelle version triée.
1. Trier un Tableau Numérique
Exemple : Tri Croissant
Utilisez OrderBy
pour trier un tableau dans l’ordre croissant.
Imports System.Linq
Module Module1
Sub Main()
Dim nombres() As Integer = {5, 3, 8, 1, 9}
' Trier en ordre croissant
Dim nombresTries = nombres.OrderBy(Function(n) n).ToArray()
' Afficher le résultat
Console.WriteLine("Nombres triés croissants : " & String.Join(", ", nombresTries))
End Sub
End Module
Résultat :
Nombres triés croissants : 1, 3, 5, 8, 9
Exemple : Tri Décroissant
Utilisez OrderByDescending
pour trier un tableau dans l’ordre décroissant.
Dim nombresTriesDesc = nombres.OrderByDescending(Function(n) n).ToArray()
Console.WriteLine("Nombres triés décroissants : " & String.Join(", ", nombresTriesDesc))
Résultat :
Nombres triés décroissants : 9, 8, 5, 3, 1
2. Trier un Tableau de Chaînes
Exemple : Ordre Alphabétique
Dim fruits() As String = {"Banane", "Pomme", "Orange", "Cerise"}
Dim fruitsTries = fruits.OrderBy(Function(f) f).ToArray()
Console.WriteLine("Fruits triés : " & String.Join(", ", fruitsTries))
Résultat :
Fruits triés : Banane, Cerise, Orange, Pomme
Exemple : Tri par Longueur de Chaîne
Dim fruitsTriesParLongueur = fruits.OrderBy(Function(f) f.Length).ToArray()
Console.WriteLine("Fruits triés par longueur : " & String.Join(", ", fruitsTriesParLongueur))
Résultat :
Fruits triés par longueur : Pomme, Cerise, Banane, Orange
3. Trier un Tableau d’Objets
Pour trier un tableau d’objets, utilisez OrderBy
avec une propriété de l’objet.
Exemple : Classe Personne
Public Class Personne
Public Property Nom As String
Public Property Age As Integer
End Class
Tri par Propriété
Dim personnes() As Personne = {
New Personne With {.Nom = "Jean", .Age = 30},
New Personne With {.Nom = "Marie", .Age = 25},
New Personne With {.Nom = "Paul", .Age = 40}
}
' Trier par âge croissant
Dim personnesTries = personnes.OrderBy(Function(p) p.Age).ToArray()
For Each personne As Personne In personnesTries
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
Résultat :
Nom : Marie, Âge : 25
Nom : Jean, Âge : 30
Nom : Paul, Âge : 40
Tri par Nom Alphabétique
Dim personnesTriesParNom = personnes.OrderBy(Function(p) p.Nom).ToArray()
For Each personne As Personne In personnesTriesParNom
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
4. Trier sur Plusieurs Critères
Vous pouvez combiner plusieurs conditions de tri avec ThenBy
et ThenByDescending
.
Exemple : Tri par Âge puis par Nom
Dim personnesMultiTries = personnes.OrderBy(Function(p) p.Age).ThenBy(Function(p) p.Nom).ToArray()
For Each personne As Personne In personnesMultiTries
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
Résultat :
Nom : Marie, Âge : 25
Nom : Jean, Âge : 30
Nom : Paul, Âge : 40
5. Utilisation des Méthodes Anonymes
Si la logique de tri est complexe, vous pouvez utiliser une méthode anonyme ou une fonction Lambda.
Exemple : Tri Personnalisé
Dim personnesCustomTries = personnes.OrderBy(Function(p) p.Age Mod 10).ToArray()
For Each personne As Personne In personnesCustomTries
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
Ici, les âges sont triés selon le reste de leur division par 10.
6. Avantages de LINQ pour le Tri
- Immuable : LINQ ne modifie pas le tableau d’origine, mais crée une nouvelle collection triée.
- Flexible : Prend en charge des conditions de tri complexes.
- Lisibilité : Les expressions LINQ sont souvent plus lisibles que d’autres approches.
7. Résumé des Méthodes LINQ de Tri
Méthode | Description |
---|---|
OrderBy | Trie les éléments en ordre croissant. |
OrderByDescending | Trie les éléments en ordre décroissant. |
ThenBy | Ajoute un critère de tri supplémentaire en ordre croissant. |
ThenByDescending | Ajoute un critère de tri supplémentaire en ordre décroissant. |
Exemple Complet
Voici un exemple combinant plusieurs types de tri avec LINQ.
Imports System.Linq
Public Class Personne
Public Property Nom As String
Public Property Age As Integer
End Class
Module Module1
Sub Main()
Dim personnes() As Personne = {
New Personne With {.Nom = "Jean", .Age = 30},
New Personne With {.Nom = "Marie", .Age = 25},
New Personne With {.Nom = "Paul", .Age = 40},
New Personne With {.Nom = "Anna", .Age = 25}
}
' Tri par âge puis par nom
Dim personnesTries = personnes.OrderBy(Function(p) p.Age).ThenBy(Function(p) p.Nom).ToArray()
Console.WriteLine("Personnes triées par âge puis par nom :")
For Each personne As Personne In personnesTries
Console.WriteLine($"Nom : {personne.Nom}, Âge : {personne.Age}")
Next
End Sub
End Module
Sortie :
Personnes triées par âge puis par nom :
Nom : Anna, Âge : 25
Nom : Marie, Âge : 25
Nom : Jean, Âge : 30
Nom : Paul, Âge : 40
Avec LINQ, le tri des tableaux en VB.Net devient à la fois facile et puissant grâce à des syntaxes claires et concises.