Comment écrire une fonction d’échange de base dans Java
Je suis nouveau sur Java. Comment écrire l’équivalent Java du code C suivant.
void Swap(int *p, int *q)
{
int temp;
temp = *p;
*p = *q;
*q = temp;
}
Voici un truc:
public static int getItself(int itself, int dummy)
{
return itself;
}
public static void main(String[] args)
{
int a = 10;
int b = 20;
a = getItself(b, b = a);
}
Tri de deux pouces
La réponse courte est: vous ne pouvez pas faire cela, Java n'a pas de pointeur.
Mais voici quelque chose de similaire que vous pouvez faire:
public void swap(AtomicInteger a, AtomicInteger b){
// look mom, no tmp variables needed
a.set(b.getAndSet(a.get()));
}
Vous pouvez le faire avec toutes sortes d'objets conteneurs (tels que des collections et des tableaux ou des objets personnalisés avec une propriété int), mais pas avec les primitives et leurs wrappers (car ils sont tous immuables). Mais la seule façon d'en faire un one-liner est avec AtomicInteger, je suppose.
BTW: si vos données se trouvent être une liste, un meilleur moyen d'échanger est d'utiliser Collections.swap(List, int, int) :
Swaps the elements at the specified positions in the specified list.
(If the specified positions are equal, invoking this method leaves
the list unchanged.)
Parameters:
list - The list in which to swap elements.
i - the index of one element to be swapped.
j - the index of the other element to be swapped.
Tri d'un tableau int []
apparemment, le véritable objectif est de trier un tableau d’ints. C'est un one-liner avec Arrays.sort(int[]) :
int[] arr = {2,3,1,378,19,25};
Arrays.sort(arr);
Pour vérifier le résultat:
System.out.println(Arrays.toString(arr));
// [1, 2, 3, 19, 25, 378]
Et voici une fonction d'assistance simple permettant d'échanger deux positions dans un tableau d'ints:
public static void swap(final int[] arr, final int pos1, final int pos2){
final int temp = arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}
Voici une méthode pour échanger deux variables entre Java sur une seule ligne = en utilisant l'opérateur binaire XOR (^).
class Swap
{
public static void main (String[] args)
{
int x = 5, y = 10;
x = x ^ y ^ (y = x);
System.out.println("New values of x and y are "+ x + ", " + y);
}
}
Sortie:
Les nouvelles valeurs de x et y sont 10, 5
Utilisez ce one-liner pour n’importe quelle classe de nombres primitifs comprenant double et float:
a += (b - (b = a));
Par exemple:
double a = 1.41;
double b = 0;
a += (b - (b = a));
System.out.println("a = " + a + ", b = " + b);
La sortie est a = 0.0, b = 1.41
Il n'y a pas d'indicateurs en Java. Cependant, chaque variable qui "contient" un objet est un référence à cet objet. Pour avoir des paramètres de sortie, vous devez utiliser des objets. Dans votre cas, les objets Integer.
Vous devez donc créer un objet contenant un entier et le modifier. Vous ne pouvez pas utiliser la classe Integer, car elle est immuable (sa valeur ne peut pas être modifiée).
Une alternative consiste à laisser la méthode renvoyer un tableau ou une paire d'ints.
Qu'en est-il du puissant IntHolder? J'adore tous les paquets avec omg dans le nom!
import org.omg.CORBA.IntHolder;
IntHolder a = new IntHolder(p);
IntHolder b = new IntHolder(q);
swap(a, b);
p = a.value;
q = b.value;
void swap(IntHolder a, IntHolder b) {
int temp = a.value;
a.value = b.value;
b.value = temp;
}
Java utilise passe-par-valeur . Il n'est pas possible d'échanger deux primitives ou objets en utilisant une méthode.
Bien qu'il soit possible d'échanger deux éléments dans un tableau entier.
Dans de tels cas, il existe une solution rapide et complexe qui utilise des tableaux contenant un seul élément:
public void swap(int[] a, int[] b) {
int temp = a[0];
a[0] = b[0];
b[0] = temp;
}
Bien entendu, votre code doit également fonctionner avec ces tableaux, ce qui est peu pratique. L'astuce de tableau est plus utile si vous souhaitez modifier une variable finale locale à partir d'une classe interne:
public void test() {
final int[] a = int[]{ 42 };
new Thread(new Runnable(){ public void run(){ a[0] += 10; }}).start();
while(a[0] == 42) {
System.out.println("waiting...");
}
System.out.println(a[0]);
}
Snippet-1
public int[] swap1(int[] values) {
if (values == null || values.length != 2)
throw new IllegalArgumentException("parameter must be an array of size 2");
int temp = values[0];
values[0]=values[1];
values[1]=temp;
return values;
}
Snippet-2
public Point swap2(Java.awt.Point p) {
if (p == null)
throw new NullPointerException();
int temp = p.x;
p.x = p.y;
p.y = temp;
return p;
}
Usage:
int[] values = swap1(new int[]{x,y});
x = values[0];
y = values[1];
Point p = swap2(new Point(x,y));
x = p.x;
y = p.y;
Java est passé par valeur. Donc, le swap dans le sens que vous voulez dire n’est pas possible. Mais vous pouvez échanger le contenu de deux objets ou le faire en ligne.
Vous ne pouvez pas utiliser de références en Java, une fonction de swap est donc impossible, mais vous pouvez utiliser l'extrait de code suivant pour chaque utilisation d'opérations de swap:
T t = p
p = q
q = t
où T est le type de p et q
Cependant, l'échange d'objets mutables peut être possible en réécrivant les propriétés:
void swap(Point a, Point b) {
int tx = a.x, ty = a.y;
a.x = b.x; a.y = b.y;
b.x = t.x; b.y = t.y;
}
Vous devez le faire en ligne. Mais vous n'avez vraiment pas besoin de cet échange en Java.
Vous pouvez échanger des variables avec ou sans utiliser une variable temporaire.
Voici un article qui fournit plusieurs méthodes pour échanger des nombres sans variable temporaire:
http://topjavatutorial.com/Java/java-programs/swap-two-numbers-without-a-temporary-variable-in-Java/
Votre fonction de permutation change essentiellement les valeurs dans deux pièces de mémoire. Toute référence à ces bits de mémoire aura désormais des valeurs différentes.
Dans Java il n'y a pas vraiment de pointeurs, donc cela ne fonctionnera pas. Au lieu de cela, les références sont conservées sur des objets, et vous ne pouvez modifier que les éléments contenus dans les objets. Si vous devez référencer un objet à deux endroits, afin que vous puissiez transmettre les mêmes valeurs dans le système et faire en sorte que les choses changent, essayez quelque chose comme modèle de référentiel ou injection de dépendance .
Nous pouvons seulement deviner pourquoi vous avez eu besoin de ce code en C. Le seul conseil que je puisse vous donner est de penser aux modifications apportées aux objets que vous souhaitez réaliser, ajoutez de préférence une méthode sur les objets eux-mêmes plutôt que d’en extraire les éléments internes, et appelez cette méthode à la place. Si cela ne vous aide pas, essayez de poster le code d'appel, car nous aurons probablement une bonne idée de la façon de résoudre le problème réel, celui de Java.
public class swaptemp {
public static void main(String[] args) {
String s1="10";
String s2="20";
String temp;
System.out.println(s1);
System.out.println(s2);
temp=Integer.toString(Integer.parseInt(s1));
s1=Integer.toString(Integer.parseInt(s2));
s2=Integer.toString(Integer.parseInt(temp));
System.out.println(s1);
System.out.println(s2);
}
}
Permuter en utilisant pointeur est pas possible en Java. Cependant, vous pouvez implémenter le swapping en passant tablea contenant deux objets.
Le code va comme ceci:
public class Swap {
public static void swap(String [] a){
String temp;
temp = a[0];
a[0] = a[1];
a[1] = temp;
}
public static void main(String [] args){
String [] foo = new String[2];
foo[0] = "str1";
foo[1] = "str2";
swap(foo);
System.out.println("First value: "+ foo[0]);
System.out.println("Second value: "+ foo[1]);
}
}
Sortie:
First value: str2
Second value: str1
Vous pouvez facilement en écrire un vous-même.
donné:
int array[]={1,2};
tu fais:
int temp=array[0];
array[0]=array[1];
array[1]=temp;
Et tu as fini. lignes de code.