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

1. Immuable : LINQ ne modifie pas le tableau d’origine, mais crée une nouvelle collection triée.
2. Flexible : Prend en charge des conditions de tri complexes.
3. 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.