La méthode d'échange à Java

  1. Échangez deux éléments dans une liste Java avec la méthode swap
  2. Permuter deux caractères dans une chaîne Java
  3. Permuter deux objets en Java

La méthode swap() est utilisée pour échanger la position de deux éléments, caractères ou objets en Java. Cette méthode peut être appliquée à une liste, une chaîne ou un objet. Dans cet article, nous allons discuter de l’utilisation de la méthode swap() dans:

  1. Permutation de deux éléments dans une liste
  2. Permutation de deux caractères dans une chaîne
  3. Échange de deux objets

Échangez deux éléments dans une liste Java avec la méthode swap

Il s’agit d’une méthode utilisée pour échanger deux éléments spécifiques dans des positions définies sans impact sur les autres éléments d’une liste. Si l’un des index spécifiés est supérieur à la taille de la liste, la méthode renvoie une exception hors limite. Le swap() donnera une sortie de la liste avec les éléments dans les index échangés.

Syntaxe:

public static void swap(List mylist, int m, int n)

Cette méthode prend trois paramètres comme arguments - la liste sur laquelle la méthode swap() sera appliquée et les deux index à échanger.

Exemple de code:

import java.util.Collections;
import java.util.ArrayList;

public class PerformSwap {
    public static void main(String[] args) {
        ArrayList<String> lettersList = new ArrayList<String>();
        lettersList.add("a");
        lettersList.add("b");
        lettersList.add("c");
        lettersList.add("d");
        lettersList.add("e");
        lettersList.add("f");
        lettersList.add("g");
        System.out.println("Original List: " + lettersList); 
        Collections.swap(lettersList, 0, 6);
        System.out.println("\nSwapped List: " + lettersList); 
    }
}

Production:

Original List: [a, b, c, d, e, f, g]

Swapped List: [g, b, c, d, e, f, a]

Dans l’exemple ci-dessus, nous avons échangé la lettre g sur l’index 6 avec la lettre a sur l’index 0. La méthode swap n’a échangé que ces deux lettres sans interférer avec aucun autre élément de la liste.

Permuter deux caractères dans une chaîne Java

L’une des principales propriétés de la valeur de chaîne est qu’elle est immuable, ce qui signifie qu’elle ne peut pas être modifiée. Pour effectuer l’opération d’échange, nous devons d’abord copier l’objet String dans un StringBuilder ou un tableau de caractères. Ces deux types de données nous permettent d’effectuer une opération d’échange sur l’objet copié. Ci-dessous, nous allons effectuer l’opération d’échange en utilisant char array et StringBuilder pour créer une nouvelle chaîne avec des caractères échangés.

Effectuer un échange de chaînes à l’aide d’un tableau de caractères en Java

La méthode d’échange a trois paramètres - la chaîne sur laquelle nous allons effectuer l’échange et les deux index des caractères que nous échangeons. Pour effectuer un échange de caractères, nous créons d’abord un objet de stockage de caractères temporaire - tempo. Cet objet temporaire stocke le premier caractère au fur et à mesure que nous le remplaçons par le deuxième caractère, puis transmet ce caractère au second caractère pour terminer le processus d’échange.

Il y a trois étapes impliquées:

  • Convertit la chaîne en un objet de tableau de caractères
  • Obtenir la longueur de l’objet
  • Permuter les index du tableau de caractères

Exemple de code:

public class SwapString {
    static char[] swap(String mystring, int i, int j)
    {
        char ch[] = mystring.toCharArray();
        char tempo = ch[i];
        ch[i] = ch[j];
        ch[j] = tempo;
        return ch;
    }
  
    public static void main(String args[])
    {
        String theS = "Favourite";

        System.out.println(swap(theS, 5, 2));
        System.out.println(swap(theS, 0, theS.length() - 1));
        System.out.println(theS);
    }
}

Production:

Farouvite
eavouritF
Favourite

Effectuer un échange de chaînes à l’aide de StringBuilder en Java

Exemple de code:

public class SwapString { 
    static String swap(String mystring, int i, int j) 
    { 
        StringBuilder mysb = new StringBuilder(mystring); 
        mysb.setCharAt(i, mystring.charAt(j)); 
        mysb.setCharAt(j, mystring.charAt(i)); 
        return mysb.toString(); 
    } 
  
    public static void main(String args[]) 
    {
        String theS = "Favorite";
  
        System.out.println(swap(theS, 5, 2)); 
        System.out.println(swap(theS, 0, theS.length() - 1)); 
  
        // Original String 
        System.out.println(theS); 
    } 
}

Production:

Faiorvte
eavoritF
Favorite

Permuter deux objets en Java

La méthode swap peut également être utilisée pour permuter les attributs des deux objets. L’échange d’objets peut être effectué sur des objets avec un attribut et également sur des objets avec plus d’un attribut.

Permuter un objet avec un attribut

Supposons que nous ayons une classe appelée Maison avec certains attributs tels que le nombre de chambres et le nombre de salles de bain. Créons deux objets de House - house1 et house2. House n’a qu’un seul attribut - value. Notre objectif est d’échanger les données dans house1 et house2.

Exemple de code:

public class SwapObjects{
    public static void swap(House house1, House house2){
        House temp = house1;
        house1 = house2;
        house2 = temp;
    }
   
    public static void main(String[] args) {
        House house1 = new House();
        House house2 = new House();

        house1.value = 5;
        house2.value = 2;

        //swap using objects
        swap(house1, house2);
        System.out.println(house1.value +", " + house2.value);
    }
}
class House {
    public int value;
}

Production:

5, 2

Permuter un objet avec plusieurs attributs en Java

Nous utilisons une classe Wrapper pour permuter l’attribut de deux objets qui ont plusieurs attributs. Si nous effectuons le swap sans la classe wrapper, le swap de fonction ne créera qu’une copie des références d’objet.

public class SwapObjects{
    public static void main(String[] args) {
        House house1 = new House(5, 3);
        House house2 = new House(2, 1);
      
        Wrapper whs1 = new Wrapper(house1);
        Wrapper whs2 = new Wrapper(house2);

        //swap using wrapper of objects
        swap(whs1,whs2);
        whs1.house.print(); 
        whs2.house.print(); 
    }

    public static void swap(Wrapper whs1, Wrapper whs2){
        House temp = whs1.house;
        whs1.house = whs2.house;
        whs2.house = temp;
    }
}
class House 
{ 
    int bedroom, bathroom; 
  
    // Constructor 
    House(int bedroom, int bathroom) 
    { 
        this.bedroom = bedroom; 
        this.bathroom = bathroom; 
    } 
  
    // Utility method to print object details 
    void print() 
    { 
        System.out.println("bedrooms = " + bedroom +  
                        ", bathrooms = " + bathroom); 
    } 
} 
class Wrapper {
    House house;
    Wrapper(House house){ this.house = house;}
}

Production:

bedrooms = 2, bathrooms = 1
bedrooms = 5, bathrooms = 3

La classe wrapper échange les objets même si la classe du membre ne donne pas accès à la classe utilisateur. Lors de l’application de la méthode swap() à un objet, vous pouvez sélectionner l’approche à utiliser en fonction du nombre d’attributs dans un objet.

Article connexe - Java String

  • Obtenir le dernier caractère d'une chaîne de caractères en Java
  • Comment convertir un tableau d'octets en String en Java