Die Swap-Methode in Java

  1. Zwei Elemente in einer Java-Liste mit der Methode swap vertauschen
  2. Zwei Zeichen in einer Java-Zeichenkette vertauschen
  3. Zwei Objekte in Java vertauschen

Die Methode swap() wird verwendet, um die Position von zwei Elementen, Zeichen oder Objekten in Java zu tauschen. Diese Methode kann auf eine Liste, eine Zeichenkette oder ein Objekt angewendet werden. In diesem Artikel besprechen wir die Verwendung der Methode swap() in:

  1. Vertauschen von zwei Elementen in einer Liste
  2. Vertauschen von zwei Zeichen in einer Zeichenkette
  3. Vertauschen zweier Objekte

Zwei Elemente in einer Java-Liste mit der Methode swap vertauschen

Dies ist eine Methode, um zwei bestimmte Elemente an definierten Positionen zu vertauschen, ohne dass dies Auswirkungen auf andere Elemente in einer Liste hat. Wenn einer der angegebenen Indizes größer ist als die Größe der Liste, dann gibt die Methode eine out of bound-Exception zurück. Die Methode swap() liefert eine Ausgabe der Liste mit den vertauschten Elementen in den Indizes.

Syntax:

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

Diese Methode nimmt drei Parameter als Argumente - die Liste, auf die die Methode swap() angewendet wird, und die beiden Indizes, die vertauscht werden sollen.

Code-Beispiel:

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

Ausgabe:

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

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

Im obigen Beispiel haben wir den Buchstaben g auf Index 6 mit dem Buchstaben a auf Index 0 getauscht. Die Methode swap hat nur diese beiden Buchstaben ausgetauscht, ohne in andere Listenelemente einzugreifen.

Zwei Zeichen in einer Java-Zeichenkette vertauschen

Eine der wichtigsten Eigenschaften des String-Wertes ist, dass er unveränderlich ist, d. h. er kann nicht verändert werden. Um die Vertauschungsoperation durchzuführen, müssen wir zunächst das String-Objekt in einen StringBuilder oder ein Zeichen-Array kopieren. Diese beiden Datentypen erlauben es uns, die Swap-Operation mit dem kopierten Objekt durchzuführen. Im Folgenden werden wir die Vertauschungsoperation mit Hilfe von Char-Array und StringBuilder durchführen, um eine neue Zeichenkette mit vertauschten Zeichen zu erstellen.

String-Swap mit Char-Array in Java durchführen

Die Swap-Methode hat drei Parameter - die Zeichenkette, die wir vertauschen wollen, und die beiden Indizes der Zeichen, die wir austauschen. Um einen Zeichentausch durchzuführen, erstellen wir zunächst ein temporäres Zeichenspeicherobjekt - tempo. Dieses temporäre Objekt speichert das erste Zeichen, während wir es durch das zweite Zeichen ersetzen, und übergibt dieses Zeichen dann an das zweite Zeichen, um den Austauschvorgang abzuschließen.

Es sind drei Schritte erforderlich:

  • Konvertieren der Zeichenkette in ein Char-Array-Objekt
  • Ermitteln der Länge des Objekts
  • Vertauschen Sie die Indizes des char-Arrays

Code-Beispiel:

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

Ausgabe:

Farouvite
eavouritF
Favourite

String-Swap mit StringBuilder in Java durchführen

Code-Beispiel:

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

Ausgabe:

Faiorvte
eavoritF
Favorite

Zwei Objekte in Java vertauschen

Die Methode swap kann auch dazu verwendet werden, die Attribute der beiden Objekte zu vertauschen. Der Objekttausch kann sowohl bei Objekten mit einem Attribut als auch bei Objekten mit mehr als einem Attribut durchgeführt werden.

Objekt mit einem Attribut tauschen

Nehmen wir an, wir haben eine Klasse namens House mit einigen Attributen wie der Anzahl der Schlafzimmer und der Anzahl der Badezimmer. Erzeugen wir zwei Objekte von House - house1 und house2. House hat nur ein Attribut - value. Unser Ziel ist es, die Daten in house1 und house2 zu vertauschen.

Code-Beispiel:

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

Ausgabe:

5, 2

Objekt mit mehr als einem Attribut in Java vertauschen

Wir verwenden eine Wrapper-Klasse, um die Attribute von zwei Objekten zu vertauschen, die mehrere Attribute haben. Wenn wir den Tausch ohne die Wrapper-Klasse durchführen, wird die Funktion swap nur eine Kopie der Objektreferenzen erzeugen.

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

Ausgabe:

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

Die Wrapper-Klasse vertauscht die Objekte auch dann, wenn die Mitgliedsklasse keinen Zugriff auf die Benutzerklasse gewährt. Wenn Sie die Methode swap() auf ein Objekt anwenden, können Sie den zu verwendenden Ansatz anhand der Anzahl der Attribute in einem Objekt auswählen.

Verwandter Artikel - Java String

  • So führen Sie die Konvertierung von String in String-Array in Java durch
  • Wie man das letzte Zeichen aus der Zeichenkette in Java entfernt