Discussion :

[abgl007]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

On peut faire aussi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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