Comment écrire une fonction de base de swap en Java [dupliquer]
19 réponses
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 entrées
la réponse courte est: vous ne pouvez pas faire cela, java n'a pas de pointeurs.
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 faire cela avec toutes sortes d'objets de conteneur (comme des collections et des tableaux ou des objets personnalisés avec une propriété int), mais tout simplement pas avec des primitives et leurs enveloppes (parce qu'ils sont tous immuables). Mais la seule façon d'en faire une doublure est avec AtomicInteger, je suppose.
BTW: si vos données se trouvent être une Liste, une meilleure façon 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.
Triing an int [] array
apparemment, l'objectif réel est de trier un tableau d'entiers.
C'est une doublure Avec Arrays.sort(int[]) :
int[] arr = {2,3,1,378,19,25};
Arrays.sort(arr);
pour vérifier la sortie:
System.out.println(Arrays.toString(arr));
// [1, 2, 3, 19, 25, 378]
et voici une fonction d'aide simple pour échanger deux positions dans un tableau de 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 en java en une seule ligne en utilisant bitwise XOR(^) operator .
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 cette doublure unique pour toute classe de nombre primitif incluant 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);
sortie a = 0.0, b = 1.41
il n'y a pas de pointeurs en Java. Cependant, chaque variable qui " contient "un objet est une référence à cet objet. Pour avoir les paramètres de sortie, vous devez utiliser des objets. dans votre cas, des objets entiers.
donc vous devriez faire un objet qui contient un entier, et changer cet entier. Vous ne pouvez pas utiliser la classe entière, car elle est immuable (c'est-à-dire que sa valeur ne peut pas être changée).
une alternative est de laisser la méthode retourner un tableau ou une paire de ints.
Qu'en est-il du puissant IntHolder? J'adore tout colis dont l'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;
}
Extrait-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;
}
Extrait-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;
}
Utilisation:
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 utilise passage par valeur . Il n'est pas possible d'échanger deux primitives ou des objets en utilisant une méthode.
bien qu'il soit possible d'échanger deux éléments dans un tableau entier.
vous ne pouvez pas utiliser de références en Java, donc une fonction de pagination est impossible, mais vous pouvez utiliser l'extrait de code suivant pour chaque utilisation d'opérations de pagination:
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 tu n'as vraiment pas besoin de ce swap en Java.
dans des cas comme celui-ci il y a une solution rapide et sale en utilisant des tableaux avec un élément:
public void swap(int[] a, int[] b) {
int temp = a[0];
a[0] = b[0];
b[0] = temp;
}
bien sûr votre code doit fonctionner avec ces tableaux aussi, ce qui est gênant. L'astuce du tableau est plus utile si vous voulez 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]);
}
votre fonction de swap change essentiellement les valeurs en deux morceaux de mémoire. Tout ce qui fait référence à ces bits de mémoire aura désormais des valeurs différentes.
en Java il n'y a pas vraiment de pointeurs, donc ça ne marchera pas. Au lieu de cela, les références sont conservées sur les objets, et vous ne pouvez changer des choses qu'à l'intérieur des objets. Si vous avez besoin de faire référence à un objet en deux endroits, de sorte que vous pouvez passer les mêmes valeurs dans le système et que les choses réagissent à leur changement, essayez quelque chose comme le motif du dépôt ou injection de dépendance .
nous ne pouvons que deviner pourquoi vous aviez besoin de ce code en C. Le seul conseil que je puisse donner est de penser aux changements des objets que vous voulez réaliser, de préférence ajouter une méthode sur les objets réels plutôt que de tirer leurs internes, et appeler cette méthode à la place. Si cela ne vous aide pas, essayez de poster le code d'appel car nous aurons probablement un bon idée de comment résoudre le vrai problème Java-style.
Java est pass by value. 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 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 temp:
vous pouvez facilement en écrire un vous-même.
:
int array[]={1,2};
vous n':
int temp=array[0];
array[0]=array[1];
array[1]=temp;
et c'est fini. 3 lignes de code.
Échange à l'aide de pointeur est pas possible en java. cependant , vous pouvez implémenter l'échange en passant le tableau contenant deux objets.
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
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);
}
}
//here is also another answer:
class SwapDemo{
static int a=1, b=2 ;
public static void main(String [] args){
Swap swp = new Swap();
swp.swaps(x,y);
System.out.println( " a (was 1)now is " + a + " b (was 2) now is " + b);
}
}
class Swap{
void swaps(int c, int d){
SwapDemo f = new SwapDemo();
f.a = c;
f.a = d;
}
}
class Swap2Values{
public static void main(String[] args){
int a = 20, b = 10;
//before swaping
System.out.print("Before Swapping the values of a and b are: a = "+a+", b = "+b);
//swapping
a = a + b;
b = a - b;
a = a - b;
//after swapping
System.out.print("After Swapping the values of a and b are: a = "+a+", b = "+b);
}
}