Как написать базовую функцию подкачки на Java

Вот один трюк:

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

Сортировка двух целых чисел

Короткий ответ: вы не можете этого сделать, в java нет указателей.

Но вот что-то подобное можно сделать:

public void swap(AtomicInteger a, AtomicInteger b){
    // look mom, no tmp variables needed
    a.set(b.getAndSet(a.get()));
}

Вы можете сделать это со всеми типами контейнерных объектов (например, коллекциями и массивами или пользовательскими объектами со свойством int), но только не с примитивами и их оболочками (поскольку все они неизменяемы). Но, думаю, единственный способ сделать это однострочным - это использовать AtomicInteger.

Кстати: если ваши данные представляют собой список, лучшим способом обмена является использование 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. 

Сортировка массива int[]

по-видимому, настоящая цель - отсортировать массив целых чисел. Это однострочник с Arrays.sort(int[]):

int[] arr = {2,3,1,378,19,25};
Arrays.sort(arr);

Чтобы проверить вывод:

System.out.println(Arrays.toString(arr));
// [1, 2, 3, 19, 25, 378]

А вот простая вспомогательная функция для замены двух позиций в массиве целых чисел:

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

Вот способ замены двух переменных в java всего в одной строке с помощью побитового оператора 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);
   }
} 

Вывод:

Новые значения x и y: 10, 5

Используйте эту однострочную строку для любого класса примитивных чисел, включая double и float:

a += (b - (b = a));

Например:

double a = 1.41;
double b = 0;
a += (b - (b = a));
System.out.println("a = " + a + ", b = " + b);

Выход a = 0.0, b = 1.41

В Java нет указателей. Однако каждая переменная, которая «содержит» объект, является ссылкой на этот объект. Чтобы иметь выходные параметры, вам пришлось бы использовать объекты. В вашем случае объекты Integer.

Таким образом, вам нужно будет создать объект, содержащий целое число, и изменить это целое число. Вы не можете использовать класс Integer, так как он неизменяем (т.е. его значение нельзя изменить).

В качестве альтернативы можно позволить методу возвращать массив или пару целых чисел.

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

public void swap(int[] a, int[] b) {
  int temp = a[0];
  a[0] = b[0];
  b[0] = temp;
}

Конечно, ваш код должен работать и с этими массивами, что неудобно. Трюк с массивом более полезен, если вы хотите изменить локальную конечную переменную из внутреннего класса:

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

А как насчет могучего IntHolder? Я просто люблю любой пакет с omg в названии!

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

Фрагмент-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;
}

Фрагмент-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;
}

Использование:

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 использует передачу по значению. Невозможно поменять местами два примитива или объекты с помощью метода.

Хотя можно поменять местами два элемента в целочисленном массиве.

Вы не можете использовать ссылки в Java, поэтому функция подкачки невозможна, но вы можете использовать следующий фрагмент кода для каждого использования операций подкачки:

T t = p
p = q
q = t

где T — тип p и q

Однако замена изменяемых объектов может быть возможна путем перезаписи свойств:

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

Вы должны сделать это в режиме онлайн. Но вам действительно не нужен этот обмен в Java.

Ваша функция подкачки по существу меняет значения в двух частях памяти. Все, что ссылается на эти биты памяти, теперь получит разные значения.

В Java на самом деле нет указателей, так что это не сработает. Вместо этого ссылки хранятся на объектах, и вы можете изменять только вещи внутри объектов. Если вам нужно сослаться на один объект в двух местах, чтобы вы могли передавать одни и те же значения по системе и чтобы все реагировало на их изменение, попробуйте что-то вроде шаблон репозитория или внедрение зависимостей.

Мы можем только догадываться, зачем вам понадобился этот код на C. Единственный совет, который я могу дать, — подумать об изменениях объектов, которых вы хотите добиться, желательно добавить метод к реальным объектам, а не вытаскивать их внутренности, и вместо этого вызовите этот метод. Если это вам не поможет, попробуйте опубликовать вызывающий код, так как у нас, вероятно, будет хорошее представление о том, как решить реальную проблему в стиле Java.

Java передается по значению. Так что swap в том смысле, который вы имеете в виду, невозможен. Но вы можете поменять местами содержимое двух объектов или сделать это встроенным.

Вы можете поменять местами переменные с использованием или без использования временной переменной.

Вот статья, которая предоставляет несколько методов для обмена числами без временной переменной:

http://topjavatutorial.com/java/java-programs/swap-two-numbers-without-a-temporary-variable-in-java/

Вы можете легко написать его самостоятельно.

данный:

int array[]={1,2};

вы делаете:

int temp=array[0];
array[0]=array[1];
array[1]=temp;

И вы сделали. 3 строки кода.

Обмен с помощью указателя не возможен в java. Однако вы можете реализовать замену путем передачи массива, содержащего два объекта.

Код выглядит следующим образом:

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

Вывод:

First value: str2
Second value: str1