Question

情况

嗯，这种方法是管理一个接受列表作为参数的转换，但肯定看不到可扩展。

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);
}

之后，它将使用long字段创建一个不同的类。

问题

但是，如果我们必须将此数据扩展到此列表中的100个参数，该怎么办？

到目前为止，我所做的是：

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++);
}

为什么递增k不是正确的方法呢？

Answer 1

k++执行后增量。换句话说，表达式的值是k的原始值，然后k递增。它在调用方法之前仍然会增加，但作为参数传递的值是增量发生之前的值。换句话说，打电话：

x = list.get(k++);

相当于：

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

所以，如果你真的有：

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

然后就可以了，相当于你的第一个代码。你目前的问题是你真的得到了：

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

但是，我建议如果您使用集合作为字段对类中的数据进行建模，那么每个值的单独字段可能会更好。（当然，您可以通过从列表中提取数据来创建类的实例，但这是另一回事。）

Answer 2

k++将返回k的值，然后递增它。

++k将递增k，然后返回递增的值。

您应该在您的情况下使用++k。

Answer 3

它工作正常，只是k++首先返回k然后将其递增1，所以你得到k，k，k + 1，k + 2等。改用++k。或者在第一次通话中使用k++，也可以选择。

Answer 4

虽然您的方法可以通过调整++位置进行一些调整，但是对于100个字段，您可能会更好地使用反射。将字段名称放入数组或列表中，然后在循环中逐个遍历它们，并根据循环变量设置值：

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));
}

这会将您的列表处理代码缩减为几行，并允许您通过按正确顺序排列array_list_data数组来更改fieldNames中字段的顺序。

Answer 5

为了管理可扩展性，我使用枚举和地图：

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()));
}

这样您就可以根据需要添加任意数量的变量，并且可以使用有意义的名称进行检索，就像在test（）方法中一样。

Answer 6

您根本不需要维护索引变量;这就是为什么我们有迭代器：

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

Answer 7

关于增量部分，试试这个：

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++);
}

这就是我在使用JDBC ResultSet时的工作方式。

Java - 在发送到方法之前递增变量

情况

问题

7 个答案: