Java - Incrementing a variable before sending to the method

Question

Situation

Well, this method is managing a conversion which accepts a list as a parameter, but definately doesn't look scalable.

List<Long> array_list_data= new ArrayList<>();

public void get_Data() {
    long0 = array_list_data.get(0);
    long1= array_list_data.get(1);
    long2= array_list_data.get(2);
}

Afterwards, it will create a different class with the long fields.

Problem

However, what if we have to expand this data to a 100 parameters on this list?

What I have done so far is:

List<Long> array_list_data= new ArrayList<>();

public void get_Data() {
    int k = 0;        
    long0= array_list_data.get(k);
    long1= array_list_data.get(k++);
    long2= array_list_data.get(k++);
}

Why incrementing k is not the right way to do it?

Answer 1

k++ performs a post-increment. In other words, the value of the expression is the original value of k, and then k is incremented. It's still incremented before the method is called, but the value passed as the argument is the value before the increment takes place. In other words, a call of:

x = list.get(k++);

is equivalent to:

int tmp = k;
k = k + 1;
x = list.get(tmp);

So if you actually had:

memory_version = array_list_data.get(k++);    // Calls with 0, then k=1
mains_voltage_min = array_list_data.get(k++); // Calls with 1, then k=2
mains_voltage_max = array_list_data.get(k++); // Calls with 2, then k=3

then it would be fine, and equivalent to your first code. Your current problem is that you've actually got:

memory_version = array_list_data.get(k);      // Calls with 0, then k=0
mains_voltage_min = array_list_data.get(k++); // Calls with 0, then k=1
mains_voltage_max = array_list_data.get(k++); // Calls with 1, then k=2

However, I'd suggest that if you're modelling the data in a class using a collection as a field, you may well be better off with a separate field for each value. (You may create an instance of the class by extracting the data from a list, of course, but that's a different matter.)

Answer 2

k++ will return the value of k then increment it.

++k will increment k then return the incremented value.

You should use ++k in your situation.

Answer 3

It works fine, just k++ does first return k and then increment it by one, so you get k, k, k+1, k+2, etc. Use ++k instead. Or use k++ in the first call, too, your choice.

Answer 4

Although your approach works fine with some tweaking of ++ position, with 100 fields you may be better off with reflection. Put field names into an array or a list, then go through them one by one in a loop, and set values based on a loop variable:

String[] fieldNames = new String[] {"memory_version", " mains_voltage_min", ...};
...
Class<MyClass> c = MyClass.class;
for (int i = 0 ; i != fieldNames.length ; i++) {
    Field f = c.getDeclaredField(fieldNames[i]);
    f.setLong(this, array_list_data.get(i));
}

This reduces your list processing code to a few simple lines, and lets you change the order of fields in array_list_data simply by arranging your fieldNames array in proper order.

Answer 5

To manage scalability, I'd use an enum and a Map:

enum Var {
    MEMORY_VERSION(0),
    MAINS_VOLTAGE_MIN(1),
    MAINS_VOLTAGE_MAX(2);

    private Integer value;
    Var(Integer value) {
        this.value = value;
    }

    public Integer value() { return value; }
}

List<Long> array_list_data= new ArrayList<>();
Map<Integer, Long> variables = new HashMap<>();

public void getData() {

    for (int j=0; j<array_list_data.size(); j++) {
        variables.put(j, array_list_data.get(j));
    }

}

public void test() {

    System.out.println("Memory version: " + variables.get(Var.MEMORY_VERSION.value()));
}

so that you can add as many vars as you need, and you can retrieve with a meaningful name, like in the test() method.

Answer 6

You don't need to maintain the index variable at all; this is why we have iterators:

final Iterator<Integer> iterator = array_list_data.iterator();
memory_version = iterator.next();
mains_voltage_min = iterator.next();
mains_voltage_max = iterator.next();

Answer 7

Just about the incrementing part, try this:

public void getData() {
    int i = 0;        
    // get element 0, then increment i
    memory_version = array_list_data.get(i++);
    // get element 1, then increment i
    mains_voltage_min = array_list_data.get(i++);
    // get element 2, then increment i
    mains_voltage_max = array_list_data.get(i++);
}

That's how I do it for example when working with JDBC ResultSet.