Обмен значений переменных java

Поменять местами две переменные в Java

Иногда нам может понадобиться поменять местами две переменные в нашем коде.

В этом уроке мы увидим несколько способов сделать это, в зависимости от типов переменных, которые мы хотим поменять местами. Затем мы проверим производительность каждого метода.

2. Простой способ: использование временной переменной​

Самый простой способ поменять местами две переменные — использовать третью переменную в качестве временного хранилища:

 Object a, b;   Object temp;  temp = a;  a = b;  b = temp; 

Этот метод особенно легко читать и понимать даже новичкам. Его основной недостаток заключается в том, что для него требуется временная переменная.

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

2.1. Почему бы не поменять метод?​

Если нам нужно поменять местами переменные в нескольких точках нашего кода, может показаться заманчивым создать метод для замены переменных следующим образом:

 public void swap(Object a, Object b) 

К сожалению, это не будет работать в Java , так как ссылки на объекты копируются во время вызова метода.

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

 private class Wrapper    public String string;   > 

 private static void swap(Wrapper a, Wrapper b)    String temp = b.string;   b.string = a.string;   a.string = temp;   > 

С помощью этого метода заключенные строки останутся замененными после возврата метода.

3. Без временной переменной​

Если наши переменные имеют примитивные типы, мы можем найти способы поменять их местами без временных переменных.

Давайте посмотрим несколько примеров.

3.1. Использование арифметических операций​

Мы можем использовать математику для замены переменных без временных переменных несколькими способами. В следующих примерах предположим, что мы хотим поменять местами два целых числа a=5 и b=10 .

Мы можем использовать сложения и вычитания для замены:

 a = a + b; // a = 15  b = a - b; // b = 5  a = a - b; // a = 10 

Или мы можем использовать умножение и деление:

 a = a * b; // a = 50  b = a / b; // b = 5  a = a / b; // a = 10 

Мы должны иметь в виду, что этот метод не работает, если какое-либо из чисел равно 0, поскольку первая операция приведет к сохранению нуля, что сделает остальную часть алгоритма бесполезной. Более того, если b = 0, будет выдано исключение ArithmeticException из-за деления на ноль.

Мы также должны позаботиться о емкости примитивов, поскольку сложение/умножение может привести к числам, превышающим максимальное значение типа примитива. Это может привести к ошибкам после замены без выдачи каких-либо исключений.

Например, если a = Integer.MAX_VALUE, то до замены a=2147483647 и b=10 и после замены a=10 , b=-1.

Если мы работаем с типами данных char , byte или short , требуется явное приведение типов, поскольку результатом арифметических операций является значение типа int по крайней мере в Java:

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

3.2. Использование логических операций​

Если мы работаем с целочисленными типами данных (например, char, short, byte, int, long ), мы можем использовать побитовый оператор исключающее ИЛИ (XOR). Оператор «^» будет обрабатывать побитовую операцию XOR для всех битов наших переменных:

 a = a ^ b; // a = 1111 (15)  b = a ^ b; // b = 1010 (5)  a = a ^ b; // a = 0101 (10) 

Мы должны знать, что, как и в случае с арифметическими операторами, побитовый оператор XOR возвращает как минимум тип данных int . Итак, мы должны привести результат XOR для каждой строки, если мы работаем с символами, байтами или короткими переменными.

3.3. Однострочный вариант​

Мы можем использовать однострочную версию методов подкачки, чтобы уменьшить размер кода:

 b = (a + b) – (a = b);  a += b – (b = a);  a = a * b / (b = a);  a = a ^ b ^ (b = a); 

Это работает, потому что выражения оцениваются с учетом приоритета операторов. Если изначально a = 5 и b = 10, последнее выражение эквивалентно a = 5 ^ 10 ^ (b = 5) . Первая операция ( 5 ^ 10 ) — это в точности первая строка многострочного алгоритма, затем мы присваиваем 5 b (скобки имеют приоритет) и, наконец, вычисляем 15 ^ 5 , что является ровно третьей строкой алгоритма.

4. Анализ производительности​

Мы только что увидели, что в Java есть несколько способов поменять местами две переменные, но какой из них более эффективен? Чтобы получить представление о производительности каждого алгоритма, мы выполнили циклы методов замены переменных и измерили время, необходимое для замены двух переменных 100 000 раз. Мы запускали тест 10 раз, чтобы рассчитать среднее время выполнения каждого алгоритма. Вот результаты:

Абсолютное время здесь не важно, так как оно зависит от машины, на которой выполняется тест. Мы только видим, что одни алгоритмы медленнее других. Это особенно верно для умножения/деления, которое значительно медленнее, либо в его однострочной версии. Напротив, алгоритм XOR наиболее эффективен как в многострочном, так и в однострочном вариантах.

Обмен объектами с временной переменной также весьма эффективен, что вполне понятно, поскольку в этом случае манипулируются только указатели.

5. Вывод​

В этой статье мы рассмотрели, как поменять местами две переменные в Java в зависимости от типа переменных.

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

Как всегда, исходный код всех примеров доступен на GitHub .

Источник

Упражнения на Java: поменяйте местами две переменные

Напишите программу на Java для замены двух переменных.

Java: обмен двух переменных

Обмен двух переменных относится к взаимному обмену значениями переменных. Как правило, это делается с данными в памяти.

Самый простой способ поменять местами две переменные — это использовать третью временную переменную:

определить своп (а, б) temp: = a a: = b б: = темп

Иллюстрированная презентация:

Пример решения :

Без использования третьей переменной.

Пример решения : —

До обмена: а, б = 15, 27 После замены: а, б = 27, 15

Блок — схема:

Пример решения (вход от пользователя):

import java.util.Scanner; public class Main < public static void main(String[] args) < int x, y, z; Scanner in = new Scanner(System.in); System.out.println("Input the first number: "); x = in.nextInt(); System.out.println("Input the second number: "); y = in.nextInt(); z = x; x = y; y = z; System.out.println(" Swapped values are3:" + x + " and " + y); >> 

Введите первое число: 36 Введите второе число: 44 Поменяемые местами значения: 44 и 36

Блок — схема:

Редактор кода Java:

Внесите свой код и комментарии через Disqus.

Каков уровень сложности этого упражнения?

Источник

The Swap Method in Java

1. Swap Two Elements in a Java List With the swap Method
2. Swap Two Characters in a Java String
3. Swap Two Objects in Java

The swap() method is used to exchange the position of two elements, characters, or objects in Java. This method can be applied to a list, a string, or an object. In this article, we will discuss the use of the swap() method in:

1. Swapping two elements in a list
2. Swapping two characters in a string
3. Swapping two objects

Swap Two Elements in a Java List With the swap Method

This is a method used to exchange two specific elements in defined positions without impacting other elements in a list. If one of the specified indexes is higher than the list’s size, then the method returns an out of bound exception. The swap() will give an output of the list with the elements in the indexes swapped.

Syntax:

public static void swap(List mylist, int m, int n) 

This method takes three parameters as its arguments — the list that the swap() method will be applied on and the two indexes which are to be exchanged.

import java.util.Collections; import java.util.ArrayList;  public class PerformSwap   public static void main(String[] args)   ArrayListString> lettersList = new ArrayListString>();  lettersList.add("a");  lettersList.add("b");  lettersList.add("c");  lettersList.add("d");  lettersList.add("e");  lettersList.add("f");  lettersList.add("g");  System.out.println("Original List: " + lettersList);  Collections.swap(lettersList, 0, 6);  System.out.println("\nSwapped List: " + lettersList);  > > 

Original List: [a, b, c, d, e, f, g]  Swapped List: [g, b, c, d, e, f, a] 

In the example above, we have exchanged the letter g on index 6 with the letter a on index 0 . The swap method has only exchanged these two letters without interfering with any other list elements.

Swap Two Characters in a Java String

One of the string value’s main properties is that it is immutable, meaning it cannot be changed. To perform the swap operation, we first have to copy the String object to a StringBuilder or a character array. These two data types allow us to perform swap operation on the copied object. Below, we’ll perform the swap operation using char array and StringBuilder to create a new string with swapped characters.

Perform String Swap Using Char Array in Java

The swap method has three parameters — the String we are going to perform swap on and the two indexes of the characters we exchange. To perform a character swap, we first create a temporary character storage object — tempo . This temporary object stores the first character as we replace it with the second character and then passes this character to the second character to complete the exchange process.

There are three steps involved:

Convert the String to a char array object

Get the length of the object

Swap the indexes of the char array

public class SwapString   static char[] swap(String mystring, int i, int j)    char ch[] = mystring.toCharArray();  char tempo = ch[i];  ch[i] = ch[j];  ch[j] = tempo;  return ch;  >   public static void main(String args[])    String theS = "Favourite";   System.out.println(swap(theS, 5, 2));  System.out.println(swap(theS, 0, theS.length() - 1));  System.out.println(theS);  > > 

Farouvite eavouritF Favourite 

Perform String Swap Using StringBuilder in Java

public class SwapString   static String swap(String mystring, int i, int j)    StringBuilder mysb = new StringBuilder(mystring);  mysb.setCharAt(i, mystring.charAt(j));  mysb.setCharAt(j, mystring.charAt(i));  return mysb.toString();  >   public static void main(String args[])    String theS = "Favorite";   System.out.println(swap(theS, 5, 2));  System.out.println(swap(theS, 0, theS.length() - 1));   // Original String  System.out.println(theS);  > > 

Faiorvte eavoritF Favorite 

Swap Two Objects in Java

The swap method can also be used to swap the two objects’ attributes. Objects swap can be performed on objects with one attribute and also on objects with more than one attribute.

Swap Object With One Attribute

Suppose we have a class called House with some attributes such as the number of bedrooms and the number of bathrooms. Let’s create two objects of House — house1 and house2 . House has only one attribute — value . Our goal is to swap the data in house1 and house2 .

public class SwapObjects  public static void swap(House house1, House house2)  House temp = house1;  house1 = house2;  house2 = temp;  >   public static void main(String[] args)   House house1 = new House();  House house2 = new House();   house1.value = 5;  house2.value = 2;   //swap using objects  swap(house1, house2);  System.out.println(house1.value +", " + house2.value);  > > class House   public int value; > 

Swap Object With More Than One Attribute in Java

We use a Wrapper class to swap the attribute of two objects that have multiple attributes. If we perform the swap without the wrapper class, the function swap will only create a copy of the object references.

public class SwapObjects  public static void main(String[] args)   House house1 = new House(5, 3);  House house2 = new House(2, 1);   Wrapper whs1 = new Wrapper(house1);  Wrapper whs2 = new Wrapper(house2);   //swap using wrapper of objects  swap(whs1,whs2);  whs1.house.print();  whs2.house.print();  >   public static void swap(Wrapper whs1, Wrapper whs2)  House temp = whs1.house;  whs1.house = whs2.house;  whs2.house = temp;  > > class House   int bedroom, bathroom;   // Constructor  House(int bedroom, int bathroom)    this.bedroom = bedroom;  this.bathroom = bathroom;  >   // Utility method to print object details  void print()    System.out.println("bedrooms = " + bedroom +  ", bathrooms = " + bathroom);  > > class Wrapper   House house;  Wrapper(House house) this.house = house;> > 

bedrooms = 2, bathrooms = 1 bedrooms = 5, bathrooms = 3 

The wrapper class swaps objects even if the member’s class doesn’t give access to the user class. While applying the swap() method to an object, you can select the approach to use based on the number of attributes in an object.

Related Article — Java String

Источник