Develop Reference

Java- passing Lists to methods working as pass by reference

There are lot of discussions in stackoverflow regarding pass by value and pass by reference. But i want to know what is happening in the following scenario?
This page says java is pass by value. Is Java "pass-by-reference" or "pass-by-value"?.
In case of following code, the the element is removed from the removeElement method , it is removing the 5th element from list when i print the list.
public class Load {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.addAll(Arrays.asList(1,1,2,3,5,5,13,21));
removeElement(list);
System.out.println(list);
}
public static void removeElement(List<Integer> list){
list.remove(5);//removes element at index 5
}
}
The output of the program is [1, 1, 2, 3, 5, 13, 21].
Can somebody explain how this is pass by value rather than pass by reference?

Java is always pass by value. The value of any variable of type Object is actually a reference. That's why, for example, == is said to be a reference comparison, and you need to use .equals() for comparing Object(s).

In case of primitives it purely pass by value and in case of Objects it is pass by value of the reference.
When you pass list from the main method to method removeElement() as an argument there is another (copy) reference that is created that points to the same List instance. Any changes made from either of the references will reflect on the same actual instance. However if you assign one of the reference to some new Object the other reference will still point to the same original instance.

Although this question asks (again) for the difference between "pass-by-value" and "pass-by-difference", I think there is an underlying misconception that causes so much confusion. This must be resolved:
As a matter of fact a method call passes all parameters by value. As Erwin Bolwidt pointed out in his comments, there are two kinds of types:
primitive types
reference types
The JLS (§4) states it:
The Java programming language is a statically typed language, which means that every variable and every expression has a type that is known at compile time.
[...]
There are two kinds of types in the Java programming language: primitive types (§4.2) and reference types (§4.3).
When speaking about "pass-by-value", it means that the content of a variable is passed by value when being used as a parameter for a method call. And the content of a reference typed variable is a reference. It is not the object that is referred to by a variable. That's a huge difference.
In your example, the content of the variable list is passed as value to the method removeElement. This value is the reference to the list object.
That further means that the method removeElement now has access to that list object (by its reference) and can manipulate it, for example remove an element. But it has no access to the content of the variable with which the method was called. So it cannot change the content of the variable list inside the main method (which would be possible with "pass-by-reference").

What are Value Types from Project Valhalla?

I've started reading about Project Valhalla and there is something I really don't understand and it's the Value Types.
This is what I understand:
1) Are objects that can't be compare it as reference?
final ValueType a = new ValueType();
final ValueType b = a;
System.out.println(a==b); returns false????
In Google AutoValue code example, it states
if(o == this){return true;}//equals method implementation what is this? I am comparing references here right?
2) According to Wikipedia, highly-efficient small 'objects' without inheritance. What do Small Objects? and Without inheritance mean?
Is this not possible using VT?
public final class ValueType extends Any //is this not possible??
3) Why are they used? Which scenario would be used and how would it be used.
4) According to Google AutoValue Library, in a nutshell, a value-typed object is an object without an identity, i.e. two value objects are considered equal if their respective internal state is equal. My question is: do they have state and should they implement equals and hashcode. What does object without an identity mean?
5) Is this assertion correct?
public static void main(final String[] args)
{
final Test clazz = new Test();
final AutoValue value = new AutoValue("Java Belongs to SUN");//Constructor Name
clazz.mutate(value);
System.out.println(value.getName()); //would print: Java Belongs to SUN??
}
private void mutate(final AutoValue value){value.setName("Java now is part of Oracle Corporation");return;}
If it is so, would JVM gain memory not tracking this Objects or Values between methods calls?
Project Valhalla is part of initial Project of Java 10 would be ready in 2018 or so.

Your final assertion is correct. The ValueType variables are entirely copied when passing them as a parameter to a function, rather than typically just getting a copy of the reference to an object. This allows you to treat a small object as if it were a value type like int or boolean.

1) Under Project Valhalla, two ValueTypes would be compared by fields directly, even for == checks, much like primitive types. With Google's AutoValue types, you would never use == directly, because that would still be an identity check.
2) Small Objects means that this should be used for objects that only have a few fields, as the whole content of the object is going to be copied repeatedly. Large objects would be better served with passes by reference.
Without Inheritance means that you won't be able to use polymorphism for Value Type objects. Because Value Types are meant to be stored directly, like primitive values, they don't include any class information, so the JVM must always be able to infer what the object is from the program itself, instead of from any information on the object. For example, an Integer field could be a Value Type member, while a Number field would have to still be by reference.
3) They are used to avoid the dereference penalty normally required for accessing an object's members. For example, with a List of Points, each Point is actually a reference to the x and y values in memory, so iterating over the list will involve many dereferences. If the Points were stored directly in the list, this would be avoided.
4) Object Without an Identity means that all that matters about the object is its value. Just as an int valued 1 should be the same as all other ints valued 1, and all Strings "hello world" are equal to all other Strings "hello world", whether or not they are actually the same object. By contrast, two ArrayLists that are both empty, while at the time equal, have identity, because they are mutable, and adding an element to one list must be distinct from adding an element to the other list.
5) Under Project Valhalla, the AutoValue, if it is a Value Object, would be immutable, so there would be no setName method to call. It would be similar to how you can never mutate 1 into 2, you instead modify where a 1 is located so that a 2 is there instead.
Source: http://cr.openjdk.java.net/~jrose/values/values-0.html

The other answers are fine, but there is one other perspective about the core point of value objects: they give you stack semantics.
Meaning: before project Valhalla, you either have primitive "objects" and
reference objects. The first ones can exist on the stack, but real objects only live on the heap.
Value objects will change that. You can have "real" objects - but their data only resides on the stack. This means that you do not have a reference (and therefore cost for de-referencing) anything - just like primitive types, the value is directly placed on the stack. But now that value can be more than just a single int, long, ... - you can have a real, "complex" object - but all its data is directly there on the stack.
And because of that, you can nicely do a == b now - because now you are no longer comparing references that point to the heap - but a and b directly have their corresponding values.

UPDATE 2019/2020, Build 14-valhalla+4-55 (2019/8/30)
Inline Class is the new name of "Value Type". According to current project state Inline Classes don't support inheritance but are able to extend interfaces. Following statement is legal:
public inline class MyInlineClass extends SomeJavaInterface {}
They do have equals, hashcode (and toString) methods. "==" operation and equals (default implementation) are same for simple case, where only Inline Classes and primitive fields are involved. But it is not true in general.
It becomes messy, if you add a classic Java Object (including String and Array) as a field inside of Inline Class. In this case "==" operation most probably won't work as expected anymore and you have to fallback to classic custom equal implementation.
Inline objects are immutable and don't support clone (clone makes no sense).
A possible usecase for Inline Classes would be complex numbers or matrix algebra, which is essential for neural networks algorithms of artificial intelligence systems.

Confused about Java passing methods (by value or reference) [duplicate]

This question already has answers here:
Is Java "pass-by-reference" or "pass-by-value"?
(93 answers)
Closed 8 years ago.
guys,
Please, can you clarify something for me?
As i understand (please correct me if i am wrong), when i pass the variables to a method or class i'm passing by value, isn't it?
if it's true, then why does Java has method .clone()?
Why do i ask this question, because i am very confused...here is the code:
if i pass variables using the following code and then modify them inside the dialog, the original values (outside) are also changed.
DialogChoosePayment mDialogChoosePayment = new DialogChoosePayment(mContext, (ArrayList<Payment>) defaultValues.getPayment(), (ArrayList<Payment>) selectedValues);
mDialogChoosePayment.show();
But, if i use the following one, then the variables values (Original variables from outside) are not changed.
DialogChoosePayment mDialogChoosePayment = new DialogChoosePayment(mContext, (ArrayList<Payment>) defaultValues.getPayment().clone(), (ArrayList<Payment>) selectedValues.clone());
mDialogChoosePayment.show();
Please, explain it to a newbie =)

Source: http://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html
Passing Primitive Data Type Arguments Primitive arguments, such as an int or a double, are passed into methods by value. This means that any changes to the values of the parameters exist only within the scope of the method. When the method returns, the parameters are gone and any changes to them are lost.
Passing Reference Data Type Arguments Reference data type parameters, such as objects, are also passed into methods by value. This means that when the method returns, the passed-in reference still references the same object as before. However, the values of the object's fields can be changed in the method, if they have the proper access level.

Java passes parameters by value. There are a lot of references on this topic. The most popular example is that you cannot simply implement method swap() that accepts 2 arguments and swaps their values.
The confusion may be caused by missunderstanding that the line like:
Object x = new Object();
indeed creates object but assigns reference to it to the variable x, so x is a reference. But if the you pass x to method you pass reference by value (or value of reference if you want).
This can give yo a tip why do we need method clone(). We need it when we want to create other object similar to the first one. Similarity means that it contains the same data and depends on the clone implementation (deep or not). But this is a absolutely another discussion.

Java has pass-by-value and only pass-by-value. At the same time Java has pointers (officially called references); so when't your passing an object to a method you're basically passing by value the variable that references that object.
If you modify the object then the object is seen to be modified at the called site. If you modify the reference to that the object in the called method, then this is not seen at the called site.
In your second case you create new objects with .clone() and pass them. Since there are no other references only in the called site, the changes can only be seen there.

when you pass (ArrayList<Payment>) defaultValues.getPayment(), you are actually passing reference to the array list. Any modifications using that reference will be reflected back to your list.
When you pass (ArrayList<Payment>) defaultValues.getPayment().clone(), you are creating a clone of the array list and passing reference to the cloned list. Any changes will be reflected only to the cloned array list not with the original array list.

In the first case you have copy of references to the objects. Surely you can change state of those objects.
In the second case you have copy of references too. But those references point to the new cloned objects.

Java Functions Passing & Returning Complex Data Types

I'm in the process of learning Java and can't help but wonder how exactly Java passes function parameters and return values. I've done some search and found that Java only passes Objects by value. However, some people challenge this; they claim that when handling Complex Data Types (not Primitive like e.g. int) it only passes a pointer.
Does this mean that whatever changes are made to the local object affect the original one? Is there any way to pass "PURELY" by value (i.e. make a hard copy of an Object)?
Furthermore, what is true about the return value? For example, we use accessors (or getter functions - I'm not completely sure how they are called) to protect the private Attributes of an ADT from being changed to "illegal" values. If Java passes the Pointer, then whatever changes I make to the returned Object of an Accessor Function also affect the actual Attribute, if it isn't a Primitive Data Type, don't they?
Could anybody please help me clarify these concepts?
Thank you in Advance! :D

The key is to understand that Java passes everything by value. And this is also true for objects: It passes the pointers by values. So, it does not create a copy of the object, but of the reference.
The same goes for returning. So, yes, your thinking is right: you can modify the attributes (called class members) objects because they get returned in the form of a pointer. That is the reason why (if needed) someone could choose to design a class whose objects are is not modifiable once it is created.

I've done some search and found that Java only passes Objects by
value.
There is your confusion. You cannot "pass objects" in Java, because objects are not values in Java. The only types in Java are primitive types and reference types (references are pointers to objects). So the only values you can manipulate in Java are primitives and pointers to objects. All types are passed or assigned by value.

If I return a List in Java, is the return value a reference or the actual value?

Pretty self explanatory: I need to modify the ArrayList that I receive, but I want the original to be unchanged.
I know this is very basic, and I'm not sure why I don't know the definitive answer. I guess better late than never though.

You will have a reference to the original ArrayList.
You can create a shallow copy of the list with clone().
Have a look at this question if you want a deep copy.

Everything in java will be a reference by default. So yes changing the returned arraylist will modify the original one.
To prevent that problem you have to create a copy of the original one. Use the .clone() method for that.

If you want a modified list, but not to modify the original, you shouldn't operate on the list which you received in arguments of the method because you operate on reference. Better use something like this:
public void modifyList(List myList) {
myList.add("aaa"); // original *will* be modified
List modifiable = new ArrayList(myList);
modifiable.add("bbb"); // original will *not* be modified - only the copy
}

It will be the same ArrayList. If you want a copy, you'll have to copy it yourself. Not necessarily easy if the ArrayList holds complex objects!

I think java is pass-by-value always.
The only thing to remember is that objects are passed by passing the value of their address, or reference to them, this makes it seem as if they are passed by reference in C++ terms. Because essentially, you are passing the reference address not a copy of the object. The address is passed by value.
Thus, Java can say it is always passed by value because even when it is passing an object, it is only passing the value of its memory reference on the heap stack, not a clone/copy of the target object.
An Arraylist is an object, therefore it will be passed by value, so the value passed in will be a reference to the original Arraylist on the heap. Any modification to the Arraylist in your function, will modify the original on the heap.
I have not used the .clone(). I leave that to others to help with. Meanwhile, I will go learn about them myself.