Demande d'aide.. nouveau chez vous les Javaien(ne)s

Bonjour
voila un petit code java pour échanger deux valeurs mais ça ne marche pas, je ne sais pas pourquoi???? :calim2:
Aidez-moi à trouver l'erreur SVP..
merci

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

package metier;   import java.util.Scanner;   public class MethodeEchangeValeurs {   public static void main(String[] args) { int a, b; Scanner clavier = new Scanner(System.in); System.out.print("Entrez une valeur pour a : "); a = clavier.nextInt(); System.out.print("Entrez une valeur pour b : "); b = clavier.nextInt(); System.out.println("a = " + a + " et b = " + b); echange(a,b); System.out.println("Après l'échange "); System.out.println("a = " + a + " et b = " + b); }   public static void echange(int x, int y) { int tmp = x; x=y; y=tmp; }   }

---

Salut,

En Java, les paramètres des méthodes sont passés :

1. par valeur pour des types primitifs (comme int par exemple). Donc changer la valeur dans le code de la méthode n'impacte pas le code appelant.
2. par copie de référence pour les types objets. Donc changer la valeur (une référence d'objet) n'impacte pas le code appelant.

Dans les deux cas, la modification de la valeur d'une variable par affectation n'a aucun effet sur le code appelant la méthode. Dans le cas d'un int, tu modifies la valeur du paramètre localement à la méthode, mais les variables du code appelant ne sont pas affectées (ce sont d'autres variables qui n'ont rien à voir en mémoire). Dans le cas d'un objet, l'affectation d'une nouvelle instance au paramètre n'a aucun effet sur la variable dans le code appelant. Mais comme la référence de l'objet est bien copiée dans le paramètre, la modification d'un attribut de l'objet est bien effective (c'est bien le même objet dans le code appelant et le code appelé).

Pour le cas particulier d'une méthode qui fait un échange des valeurs de deux variables, on ne peut pas le faire, puisqu'il n'est pas possible de modifier les valeurs des variables du code appelant. La solution sera de passer un conteneur : un objet qui va contenir des attributs qui auront les valeurs à échanger, par exemple dans deux variables, dont on pourra alors changer le valeurs.

Ce genre de méthode est donc difficile à écrire de façon concise en Java.

Par exemple, on peut utiliser un tableau (en guise de conteneur) :

Code:

---

1 2 3 4 5

public void echanger(int[] var) { int echanger = var[0]; var[0]=var[1]; var[1]=echanger; }

---

Mais l'appel est fastidieux et non transparent.

Code:

---

1 2 3 4 5 6

int a=1; int b=2; int[] tab = {a;b}; echanger(tab); a=tab[0]; b=tab[1];

---

De la même façon, le code est similaire au niveaux des affectations pour une classe avec deux attributs.

Pour un code plus concis, il y a une combine du genre

Code:

---

1 2 3

public int echanger(int a, int b) { return b; }

---

mais qui oblige quand même à faire un appel spécial, donc pas très transparent

Code:

---

1 2 3

int a=1; int b=2; a = echanger(b, b=a);

---

On peut faire aussi :

Code:

---

1 2 3

public void echanger(AtomicInteger a, AtomicInteger b){ a.set(b.getAndSet(a.get())); }

---

Code:

---

1 2 3

AtomicInteger a = new AtomicInteger(1); AtomicInteger b = new AtomicInteger(2); echanger(a,b);

---

Dans ce cas, les valeurs des variables a et b (qui sont des références d'objets) du code appelant ne sont pas modifiées, mais les variables qu'elles contiennent (des attributs des objets), qui valent les valeurs qu'on gère (le 1 et le 2) sont bien affectées, et donc on a bien échange de valeurs dans le code appelant (mais pas des objets).

Si on a vraiment besoin de ce genre de chose dans un algorithme (échanger 2 variables), on pourra faire une classe :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

public class Couple<T,T> {   private T a; private T b;   public Couple(T a, T b) { this.a=a; this.b=b; }   public T getA() { return a; }   public T getB() { return b; }   public void swap() { T e=a; a=b; b=e; }   }

---

Code:

---

1 2 3

Couple<Integer,Integer> couple = new Couple<>(1,2); couple.swap(couple); System.out.println( couple.getA() + " "+ couple.getB()); // affiche 2 1

---

Une autre solution serait :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class Wrapper<T> { private T value; public Wrapper(T value) { this.value=value; } public T getValue() { return value; } public void swap(Wrapper<T> other) { T temp = other.value; other.value=this.value; this.value=temp; } public String toString() { return String.valueOf(value); } }

---

Code:

---

1 2 3

Wrapper<Integer> a = new Wrapper<>(1); Wrapper<Integer> b = new Wrapper<>(2); a.swap(b);

---

Enfin, on peut aussi procéder avec une List, par décalage :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public static void main(String[] args) { List<Integer> l = new ArrayList<>(Arrays.asList(1,2)); shiftLeft(l); System.out.println(l); }   public static <T> void shiftLeft(List<T> list) { if ( list.size()>1 ) { list.add(list.remove(0)); } }

---