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
.
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
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
Pour trier un tableau d’objets, utilisez Array.Sort
avec une fonction de comparaison personnalisée ou une expression Lambda.
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
LINQ (Language Integrated Query) offre une manière plus expressive de trier des tableaux.
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
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
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
Si vous souhaitez trier selon une logique complexe, utilisez IComparer
ou une fonction de comparaison.
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
Array.Sort
et LINQ permettent de trier selon différentes logiques.Array.Sort
modifie le tableau original. Pour conserver le tableau d’origine, utilisez LINQ pour retourner un tableau trié.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
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. |
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.
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
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
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
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
Pour trier un tableau d’objets, utilisez OrderBy
avec une propriété de l’objet.
Public Class Personne
Public Property Nom As String
Public Property Age As Integer
End Class
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
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
Vous pouvez combiner plusieurs conditions de tri avec ThenBy
et ThenByDescending
.
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
Si la logique de tri est complexe, vous pouvez utiliser une méthode anonyme ou une fonction Lambda.
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.
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. |
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.
Télécharger un canevas Word Présentation d’Entreprise ⬇︎ 1. Définition : Qu’est-ce qu’une Présentation d’Entreprise ?…
Le dossier professionnel est un document essentiel pour structurer et valoriser un parcours professionnel. Il…
Une présentation de dossier est un document structuré qui permet d’exposer de manière claire et…
Maîtriser la Syntaxe en Français La syntaxe est l'un des piliers fondamentaux de la langue…
Dans le marché compétitif d'aujourd'hui, une proposition de valeur pertinente est primordiale pour distinguer une…
Lors de l’élaboration ou de la révision d’un texte législatif, réglementaire ou statutaire, les propositions…
This website uses cookies.