Question

我有一个整数数组，我试图根据某些条件将for循环迭代回它访问的最后一个索引，让我说我在该循环中有2 9 15 19 23 28 37个元素我给出的条件是如果该循环的每个元素都大于一个数字，例如8，它将再次处理该元素。

我的代码是

List<Integer> result = new ArrayList<Integer>();
int n = 6;
for (int i = 0; i < n; i++) {
    int h = 8;
    int r = a[i] - h;
    if (r <= 0) {
        result.add(1);
    } else if (r >= 0) {
        result.add(1);
    }
}

这里的h是包含声明元素的数组.r是一个整数，用于检查元素是否大于命中元素，即8.如果条件是元素小于ar，则arraylist将添加1，否则对于相同的元素，控制将返回到操作int r = a [i] -h。例如，2小于8，arraylist将添加1，但对于9，控件将执行相同的减运操作并且来到else部分并向arraylist添加1.循环处理的最后一个元素如果不为零将不会被添加到列表中。这是可能的吗？请帮忙。

Answer 1

您可以通过--i退回：

if (a[i] - h > 0) {
    // a[i] is greater than h
    --i; // process a[i] again on the next iteration
}

正如@Stefan Warminski注意到它会导致无限循环，因为我们总是会处理第一个元素，而不是大于h。

解决方法可能是创建一个与原始列表长度相同的数组int[] changes，并将值放入适当的单元格中，该单元格将指示我们处理changes[i]元素的次数a[i] ：

if (a[i] - h > 0 && changes[i]++ < N) { ... }

其中N是您要处理元素的次数。

完整的代码段：

int[] a = {2, 9, 15, 19, 23, 28, 37};
int[] changes = new int[a.length];

int h = 8;
int N = 2;

for (int i = 0; i < a.length; i++) {
    if (a[i] - h > 0 && changes[i]++ < N) {
        System.out.println(a[i] + " is processed " + changes[i] + " times");
        --i;
    }
}

输出：

9 is processed 1 times
9 is processed 2 times
15 is processed 1 times
15 is processed 2 times
19 is processed 1 times
19 is processed 2 times
23 is processed 1 times
23 is processed 2 times
28 is processed 1 times
28 is processed 2 times
37 is processed 1 times
37 is processed 2 times

提示：在h语句之外声明for变量，它不会在内部发生变化（不需要在每次迭代时创建变量）。

Answer 2

请注意，测试r<=0是无用的：您可以在测试之外使用result.add(1)，因为无论如何都要执行此操作。

int h=8;
for(int i=0;i<n;i++){
    int r = a[i] -h;
    result.add(1);
    if(r >=0){
        'loop back'
    }
}

然后，如果您的目标是“再次处理该元素”，您真的需要迭代回来吗？您已经拥有该元素，只需再次处理它。

List<Integer> result = new ArrayList<Integer>();
int n =6;
int h=8;
for(int i=0;i<n;i++){
    int r = a[i] -h;
    result.add(1); // Processed once
    if(r >=0){
        result.add(1); // Processed twice
    }
}

Answer 3

List<Integer> result = new ArrayList<Integer>();
int n =6;
for(int i=0;i<n;i++){
    int h=8;
    int r = a[i] -h;
    if(r <=0){
        result.add(1);
    }else if(r >=0){
        result.add(1); 
        i--;           
    }
}

使用此代码，您可以再次处理大于8的数字。如果r> = 0，则i递减，并且再次处理大于8的数字。

Answer 4

如果我理解正确，你想要多次处理一个元素，仅当该元素满足某些条件时。

您可以简单地遍历列表，然后如果元素大于h，您只需执行所需的操作（在我的情况下为System.out.println()）n次。

List<Integer> list = Arrays.asList(2, 9, 15, 19, 23, 28, 37);

int h = 8;
int n = 2;
list.stream().forEach(t -> {
    int r = (t > h ? n : 1);
    for (int i = 0; i < r; i++) {
        System.out.println(t);
    }
});

或以下Java-8版本：

List<Integer> list = Arrays.asList(2, 9, 15, 19, 23, 28, 37);

int h = 8;
int n = 2;
for (int t : list) {
    int r = (t > h ? n : 1); // Execute 'n' times if condition is met,
                             // otherwise, execute once
    for (int i = 0; i < r; i++) {
        System.out.println(t); // Code you want to execute
    }
}

此外，

int h = 8;
int r = a[i] - h;
if (r <= 0) {
    result.add(1);
}
else if (r >= 0) {
    result.add(1);
}

没有意义。实际上，您要将a[i]与h进行比较。以下代码具有相同的效果：

int h = 8;
result.add(1);
if (a[i] == h) {
    // Add the number 1 again to the list
    result.add(1);
}

如何将for循环迭代回到它在java中访问的最后一个索引

4 个答案: