Java-метод для замены примитивов

Ответ 1

Вы не можете создать метод swap, так что после вызова swap(x,y) значения x и y будут заменены. Вы можете создать такой метод для изменяемых классов, заменив их содержимое¹, но это не изменило бы их идентификатор объекта, и вы не смогли бы определить общий метод для этого.

Однако вы можете написать метод, который обменивает два элемента в массиве или списке, если это вам нужно.

¹ Например, вы можете создать метод подкачки, который принимает два списка, и после выполнения метода список x будет иметь предыдущее содержимое списка y, а в списке y будет указано предыдущее содержимое списка x.

Ответ 2

Я думаю, что это самое близкое к простому обмену, но у него нет простого шаблона использования:

int swap(int a, int b) {  // usage: y = swap(x, x=y);
   return a;
}

y = swap(x, x=y);

Он полагается на то, что x перейдет в swap, прежде чем y будет присвоено x, тогда x возвращается и назначается y.

Вы можете сделать его общим и заменить любое количество объектов одного типа:

<T> T swap(T... args) {   // usage: z = swap(a, a=b, b=c, ... y=z);
    return args[0];
}

c = swap(a, a=b, b=c)

Ответ 3

Это зависит от того, что вы хотите сделать. Этот код заменяет два элемента массива.

void swap(int i, int j, int[] arr) {
  int t = arr[i];
  arr[i] = arr[j];
  arr[j] = t;
}

Что-то вроде этого обменивает содержимое двух int[] равной длины.

void swap(int[] arr1, int[] arr2) {
  int[] t = arr1.clone();
  System.arraycopy(arr2, 0, arr1, 0, t.length);
  System.arraycopy(t, 0, arr2, 0, t.length);
}

Что-то вроде этого заменяет содержимое двух BitSet (используя алгоритм обмена XOR):

void swap(BitSet s1, BitSet s2) {
  s1.xor(s2);
  s2.xor(s1);
  s1.xor(s2);
}

Что-то вроде этого заменяет поля x и y некоторого класса Point:

void swapXY(Point p) {
  int t = p.x;
  p.x = p.y;
  p.y = t;
}

Ответ 4

По-видимому, у меня недостаточно репутационных баллов, чтобы прокомментировать ответ Дансальмо, но он хороший, хотя и с неправильным названием. Его ответ на самом деле K-комбинатор.

int K( int a, int b ) {
    return a;
}

JLS специфичен для оценки аргументов при переходе к методам /ctors/etc. (Это было не так в старых спецификациях?)

Конечно, это функциональная идиома, но она достаточно понятна тем, кто ее распознает. (Если вы не понимаете код, который вы нашли, не связывайтесь с ним!)

y = K(x, x=y);  // swap x and y

K-комбинатор специально разработан для такого рода вещей. AFAIK нет причин, по которым он не должен проходить проверку кода.

Мои $ 0,02.

Ответ 5

AFAIS, никто не упоминает атомную ссылку.

Целое число

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

Строка

public void swap(AtomicReference<String> a, AtomicReference<String> b){
    a.set(b.getAndSet(a.get()));
}

Ответ 6

Я мог бы сделать что-то вроде следующего. Конечно, с богатством классов Collection, я не могу себе представить, что когда-либо понадобится использовать это в любом практическом коде.

public class Shift {
  public static <T> T[] left (final T... i) {
    if (1 >= i.length) {
      return i;
    }
    final T t = i[0];
    int x = 0;
    for (; x < i.length - 1; x++) {
      i[x] = i[x + 1];
    }
    i[x] = t;
    return i;
  }
}

Вызывается с двумя аргументами, это своп.

Его можно использовать следующим образом:

int x = 1;
int y = 2;
Integer[] yx = Shift.left(x,y);

В качестве альтернативы:

Integer[] yx = {x,y};
Shift.left(yx);

Тогда

x = yx[0];
y = yx[1];

Примечание: это примитивы с автоматическими коробками.

Ответ 7

Попробуй эту магию

public static <T> void swap(T a, T b) {
    try {
        Field[] fields = a.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object temp = field.get(a);
            field.set(a, field.get(b));
            field.set(b, temp);
        }
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

И проверить это!

    System.out.println("a:" + a);
    System.out.println("b:" + b);
    swap(a,b);
    System.out.println("a:" + a);
    System.out.println("b:" + b);

Ответ 8

Для целочисленных типов вы можете сделать

a ^= b;
b ^= a;
a ^= b;

используя побитовый оператор xor ^. Как и все другие предложения, вы, вероятно, не должны использовать его в рабочем коде.

По причине, которую я не знаю, однострочная версия a ^= b ^= a ^= b не работает (возможно, в моем компиляторе Java есть ошибка). Одна строка работала на C со всеми компиляторами, которые я пробовал. Тем не менее, двухстрочные версии работают:

a ^= b ^= a;
b ^= a;

а также

b ^= a;
a ^= b ^= a;

Доказательство того, что это работает: пусть a₀ и b₀ будут начальными значениями для a и b. После первой строки a имеет вид a₁ = a₀ xor b₀; после второй строки b имеет вид b₁ = b₀ xor a₁ = b₀ xor (a₀ xor b₀) = a₀. После третьей строки a имеет вид a₂ = a₁ xor b₁ = a₁ xor (b₀ xor a₁) = b₀.

Ответ 9

public class Swap1 {
    public static void main(String[] args){
        int x =7;
        int y = 3;

        swap(x,y);

        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }

    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
}