swapping of objects in java [duplicate]

Answer 1

public static void swap(SwapDate[] t)
    {
     SwapDate temp;;
      temp=t[0];
       t[0]=t[1];
       t[1]=temp;
    }




       public static void main(String args[])throws Exception{

          SwapDate t[]=new SwapDate[5];
           t[0]=new SwapDate(20,8,2015);
           t[1]=new SwapDate(8,8,2015);

           System.out.println("(First object)Account Opnening date :"+" "+t[0].date);
           System.out.println("(second object)Account Opnening date :"+" "+t[1].date);


           swap(t);
           System.out.println("After Swap");

           System.out.println("(First object)Account Opnening date :"+" "+t[0].date);
           System.out.println("(second object)Account Opnening date :"+" "+t[1].date);


           }

Answer 2

You studied wrong sources. Java is pass by value. Here is one source more you can study. And from here you can find discussion about example similar to yours.

Answer 3

We can swap objects. It's so simple.Just have to use one dummy object to swap two objects.

Example is given below:

    Employee e1=new Employee();
    Employee e2=new Employee();
    e1.setName("e1");
    e2.setName("e2");   
    System.out.println(e1);
    System.out.println(e2);
    Employee temp= new Employee();
    temp=e1;
    e1=e2;
    e2=temp;

Answer 4

Java passes references by value; swapping references in the method being called has no effect in the caller. Your strings are immutable, so there is nothing you can do to them in the swap method that would be visible to the caller.

If you pass mutable objects, however, you will see that changes to them made in the swap would reflect in the original:

public static void main(String[] args) {
    String a[] = {"hello", "world"};
    swap(a);
    System.out.println(a[0] + " " + a[1]);
}
static void swap(String[] a) {
    String t = a[0];
    a[0] = a[1];
    a[1] = t;
}

This works, because array is mutable (i.e. changes can be made to its state), and because a reference to the original object is passed to the function being called (by value). When swap modifies the content of its a, the content of a in the caller gets modified too, because it is the same object.

Answer 5

What gets passed to a method is a copy of the reference of the object. So, no matter how many times you re-assign the references, the original reference will not be affected.

Try this:

static void reverse(StringBuilder builder) {
    builder.reverse();
}

public static void main(String[] args) {
    StringBuilder builder = new StringBuilder("hello");
    System.out.println(builder);
    reverse(builder);
    System.out.println(builder);
}

However, the below method wouldn't make any difference to the original object passed in.

static void swap(StringBuilder builder) {
    builder = null;
}

Answer 6

Java always passes the references by value. Read this answer for more details. However, you can swap two strings via arrays or wrapper classes.

---

EDIT:

@dasblinkenlight shows how to use arrays to swap two strings, and here is an example of using wrapper class:

public class WrapperString
{
    public String text;

    public WrapperString(String text){this.text = text}

    @Override
    public String toString(){return text;}
}

public static void swap(WrapperString a, WrapperString b)
{
    String temp = a.text;
    a.text = b.text;
    b.text = temp;
}

public static void main(String[] args)
{
    WrapperString s1 = new WrapperString("Hello");
    WrapperString s2 = new WrapperString("World");

    swap(s1, s2);
    System.out.println(s1.text + s2.text);
    // or System.out.println(s1 + s2); since we've already overridden toString()
}

OUTPUT:

WorldHello