Échangez deux cordes en Java, en les transmettant à une fonction utilitaire, mais sans retourner des objets ou en utilisant des cours d'emballage

Fondamentalement, vous ne pouvez pas implémenter la méthode code> code> en Java.

La raison pour laquelle vous ne pouvez pas faire est que l'argument de Java a une sémantique d'argument passe-valeur. Donc, lorsque votre méthode attribue code> attribue S2 code> à S1 code> etc., il fonctionne entièrement sur les variables em> locales em> Code> S1 code> et S2 code> et non sur le S1 code> et S2 code> variables dans la méthode d'appel principale code >. P>

En revanche, si vous deviez implémenter la méthode code> Swap code> en C, il ressemblerait à ceci: P>

char *s1 = "Hello World";
char *s2 = "Goodbye World";
swap(&s1, &s2);

Les variables S1 et S2 de votre fonction Swap sont locales sur cette fonction.

Vous devez définir S1 et S2 en tant que variables privées pour votre classe ou renvoyer une gamme de chaînes de votre fonction.

Étant donné que Java utilise une valeur de réussite, la fonction d'échange que vous avez définie ne fait aucun type d'échange; Les pointeurs S1 et S2 sont échangés localement, mais le résultat du swap ne persiste pas. La chose la plus proche que vous puissiez réaliser est d'envelopper les éléments que vous souhaitez échanger dans une classe et de définir une méthode d'échange dans cette classe. Cela vous permettra d'échanger des données entre les instances de cette classe, bien qu'elle ne échange pas réellement les données sous-jacentes. À titre d'exemple de ceci:

  public class Swapper<T> {
      public Swapper(T obj) {
             data_ = obj;
      }
      public T get() { return data_; }
      public void set(T value) { data_ = value; }
      public void swap(Swapper<T> o) {
           T tmp = o.data_;
           o.data_ = data_;
           data_ = tmp;
      }
      private T data_ = null;
  }

  // .. Now you can do:
  Swapper<String> a = new Swapper("Hello");
  Swapper<String> b = new Swapper("World");
  // a.get().equals("Hello")
  a.swap(b); // now a.get().equals("World")

Il y avait Une question très similaire récemment à propos de l'échange de deux int. Et Ma réponse alors était à Utilisez Références atomiques :

public void swap(AtomicReference<String> a, AtomicReference<String> b){
    // update: look mom, no variables
    a.set(b.getAndSet(a.get()));
}

Le code suivant est un nogo fort>, jamais implémenter ce modèle anti-modèle, ne jamais jamais modifier les internes finales privées sur des objets immuables. Ne me blâmez pas pour montrer ce piratage, blâmer le JVM d'Oracle pour ne pas le refuser.

Mais, si un jour vous trouvez du code où cela fonctionne: P>

 private void swap(String a, String b) {
   try {
     Field value = String.class.get("value");
     value.setAccessible(true);    // this should be forbidden!!

     char[] temp = value.get(a);
     value.set(a, value.get(b));
     value.set(b, temp);           // Aaargh, please forgive me
   } catch(Exception e) {
     e.printStackTrace(e);
   }
 }

Java String code> s sont implémentés avec des références, vous devez donc échanger leurs références.

World Hello

String s1 = "Hello";
String s2 = "World";
    s1=s1+" "+s2;
s2=s1.split(" ")[0];
s1=s1.split(" ")[1];
System.out.println(s1 + " " + s2);

En utilisant StringBufferreader code> et StringBuilder code> Ceci peut être résolu. Au 1er, obtenez les valeurs de l'utilisateur, puis divisez-les et rangez-les en tableau. Exécutez la boucle pour l'ordre inverse de sorte que la dernière chaîne soit ajoutée et affichée 1er le premier affichera en dernier. Entrée: Bonjour World Sortie:

import java.io.*;
import java.util.*;
import java.lang.*;
public class Solution {
  public static void main(String[] args) {
    try {
      int s,i,j;
      StringBuilder str = new StringBuilder();
      String st,t;
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      t = br.readLine();
      s = Integer.parseInt(t);
      for (i = 0; i < s; i++) {
        st=br.readLine();
        String st1[]=st.split("\\s+");
        // System.out.println("l="+st1.length);
        for (j = st1.length - 1; j >= 0; j--) {
          str.append(st1[j] + " ");
        }
        System.out.println(str);
        str.setLength(0);
      }
    } catch (Exception e) {
      System.out.println(e);
    }
  }
}

Java passe l'adresse des objets dans la mémoire aux fonctions. Ensuite, une variable locale dans la fonction contient cette adresse. Il n'y a aucune raison de modifier l'objet d'origine si vous attribuez une nouvelle adresse (un autre objet) à ces variables locales.

Cependant, des modifications apportées à les champs de l'objet d'origine, avec l'adresse en main, sont appliquées. (Relation à . Opérateur en C / C ++)

Ce lien peut également aider.