Il metodo Swap in Java

  1. Scambia due elementi in una lista Java con il metodo swap
  2. Scambia due caratteri in una stringa Java
  3. Scambia due oggetti in Java

Il metodo swap() viene utilizzato per scambiare la posizione di due elementi, caratteri o oggetti in Java. Questo metodo può essere applicato a una lista, una stringa o un oggetto. In questo articolo, discuteremo dell’uso del metodo swap() in:

  1. Scambiare due elementi in una lista
  2. Scambiare due caratteri in una stringa
  3. Scambiare due oggetti

Scambia due elementi in una lista Java con il metodo swap

Questo è un metodo utilizzato per scambiare due elementi specifici in posizioni definite senza influire sugli altri elementi in una lista. Se uno degli indici specificati è maggiore della dimensione dell’lista, il metodo restituisce un’eccezione out of bound. Lo swap() darà un output della lista con gli elementi negli indici scambiati.

Sintassi:

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

Questo metodo accetta tre parametri come argomenti: l’lista su cui verrà applicato il metodo swap() ei due indici che devono essere scambiati.

Esempio di codice:

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); 
    }
}

Produzione:

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

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

Nell’esempio sopra, abbiamo scambiato la lettera g sull’indice 6 con la lettera a sull’indice 0. Il metodo swap ha scambiato solo queste due lettere senza interferire con altri elementi della lista.

Scambia due caratteri in una stringa Java

Una delle proprietà principali del valore di stringa è che è immutabile, il che significa che non può essere modificato. Per eseguire l’operazione di scambio, dobbiamo prima copiare l’oggetto String in uno StringBuilder o in un array di caratteri. Questi due tipi di dati ci consentono di eseguire un’operazione di scambio sull’oggetto copiato. Di seguito, eseguiremo l’operazione di scambio utilizzando l’array di caratteri e StringBuilder per creare una nuova stringa con i caratteri scambiati.

Eseguire lo scambio di stringhe utilizzando Char Array in Java

Il metodo di scambio ha tre parametri: la stringa su cui eseguiremo lo scambio ei due indici dei caratteri che scambiamo. Per eseguire uno scambio di caratteri, creiamo prima un oggetto di memorizzazione temporaneo del carattere - tempo. Questo oggetto temporaneo memorizza il primo carattere mentre lo sostituiamo con il secondo carattere e quindi passa questo carattere al secondo carattere per completare il processo di scambio.

Ci sono tre passaggi coinvolti:

  • Converte la stringa in un oggetto array di caratteri
  • Ottieni la lunghezza dell’oggetto
  • Scambia gli indici dell’array di caratteri

Esempio di codice:

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);
    }
}

Produzione:

Farouvite
eavouritF
Favourite

Eseguire lo scambio di stringhe utilizzando StringBuilder in Java

Esempio di codice:

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); 
    } 
}

Produzione:

Faiorvte
eavoritF
Favorite

Scambia due oggetti in Java

Il metodo swap può essere utilizzato anche per scambiare gli attributi dei due oggetti. Lo scambio di oggetti può essere eseguito su oggetti con un attributo e anche su oggetti con più di un attributo.

Scambia oggetto con un attributo

Supponiamo di avere una classe chiamata House con alcuni attributi come il numero di camere da letto e il numero di bagni. Creiamo due oggetti di House - house1 e house2. House ha un solo attributo: value. Il nostro obiettivo è scambiare i dati in house1 e house2.

Esempio di codice:

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;
}

Produzione:

5, 2

Scambia oggetti con più di un attributo in Java

Usiamo una classe Wrapper per scambiare l’attributo di due oggetti che hanno più attributi. Se eseguiamo lo scambio senza la classe wrapper, la funzione swap creerà solo una copia dei riferimenti all’oggetto.

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;}
}

Produzione:

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

La classe wrapper scambia gli oggetti anche se la classe del membro non concede l’accesso alla classe utente. Mentre applichi il metodo swap() a un oggetto, puoi selezionare l’approccio da usare in base al numero di attributi in un oggetto.

Articolo correlato - Java String

  • Caratteri di escape in Java
  • Converti una stringa in un Int in Java