Reference to a Variable in List

Question

Sorry for the vague title, hopefully I can make my question clearer here.

I have some two-dimensional List<List<Double>> myList that contains two items each sublist: one explicit double, such as 2.0, and one double variable. Essentially what I want to do is instead of storing some constant value in the list, I want it to store a reference to the variable, because the variable will be changing in other parts of the program and the list should reflect that. Here is a very simplified version of what I want to do:

import java.util.Arrays;
import java.util.List;

public class Example {

    static double apples = 10.0;

    static double oranges = 5.0;

    static List<List<Double>> myList = Arrays.asList((Arrays.asList(2.0, apples)), (Arrays.asList(2.0, oranges)));

    public static void main(String[] args) {

        apples += 3;

        oranges += 3;

        for (List<Double> list : myList) {

            // list.get(1) -= list.get(0);

            System.out.println(list.get(1) - list.get(0));

        }

    }

}

The program output is the following:

8.0
3.0

However, it should be:

11.0
6.0

Because apples and oranges were both increased by 3. Furthermore, notice the commented out line list.get(1) -= list.get(0);. What I ultimately want to do is reduce the variable specified by list.get(1) by the amount specified by list.get(0). However, when I uncomment this line I get:

Error:(20, 25) java: unexpected type
  required: variable
  found:    value

I am thinking that both of these issues are due to the value of apples and oranges being stored in the list as constant values, and not a reference to the actual variables themselves. Is this because of me using Arrays.asList() to create myList? Or is it a problem in the way I define List<List<Double>>? Or is it some other problem altogether?

Thank you for any help.

Answer 1

The primary issues you're coming across are about mutability and references.

Object variables have a reference as their value, and then get dereferenced as needed. The assignment operator changes the reference, not the value underlying it. The Java Double wrapper class is immutable, so you can't change it's value.

apples += 3;
oranges +=3;

Doesn't add 3 to the value of the objects apples/oranges point to, but rather creates a new Double object with a value 3 greater than apples/oranges. apples/oranges are then assigned a reference to the respective objects. Your lists still have references to the old objects.

You could create a wrapper class, as Martín Zaragoza suggested, an extremely basic one, with a public member and only a constructor would look like this:

public class MutableDouble {
    public double value
    public MutableDouble(double iV){
        this.value = iV
    }
}

You could then assign apples and oranges as MutableDouble values, and change the apples.value and oranges.value fields.

You could also use an AtomicReference as stephane k. suggests in the comments below.

include java.util.concurrent.atomic.AtomicReference;

Then:

AtomicReference apples = new AtomicReference(2.0);
System.out.println(apples);
apples.set((double)apples.get() + 5.0);
System.out.println(apples);

Output:

2.0
7.0

If you change the underlying object, rather than reassigning the variable to a new object, the other areas of your code that reference that object will see the change.

Regarding your issue with the subtraction, you're trying to assign a value to a value. list.get(1) returns a double, so you're basically saying 10.0 = 8.0. Try this:

list.set(1, list.get(1) - list.set(0));

This will assign the value of the subtraction to the item at index 1 in the list.

Answer 2

Example for understanding

public static void main( String[] args ) {
    class testClass {
        int b;

        @Override
        public String toString() {
            return "testClass{" +
                    "b=" + b +
                    '}';
        }
    }
    List<Double> d = new ArrayList<>();
    Double dd = new Double("2.0");
    d.add(dd);
    System.out.println(d.toString());
    dd = 3.0;
    System.out.println(d.toString());


    List<testClass> tList = new ArrayList<>();
    testClass t = new testClass();
    t.b =1;
    tList.add(t);
    System.out.println(tList.toString());
    t.b=2;
    System.out.println(tList.toString());
}

output

[2.0]
[2.0]
[testClass{b=1}]
[testClass{b=2}]