在布尔数组中迭代trues的快速方法

Question

I have a big array of booleans and i need just to work with the true elements, and need theyer index.

for (int x = 0; x < cells.length; x++) {
        for (int y = 0; y < cells[0].length; y++) {

                if (cells[x][y]) {
                    g.fillRect(x * cellSize, y * cellSize, cellSize, cellSize);
                }

        }
    }

so how can i do that without the two foor loops and save the time?

Answer 1

I'd say this is the best you can get.

You are already using a primitive array and I expect primitive boolean type.

The only thing I could suggest is saving cells.length and cells[0].length in final variables before the loops, it could save some time, but the compiler may already optimize this on its own.

Answer 2

不幸的是，由于你的要求，你被困在O(n) ......意思是，你必须观察一次数组中的每个值，找到具有true值的所有cells

Answer 3

您可以实现一些数组包装器 ，它将链接true值（以设置操作的成本），这样您就可以只迭代true索引。

Answer 4

We can do by this, Convert int[array] to String and find index where 1 present. Based on index perform the operation.

String arrayStr=Arrays.toString(cells[0].length);

String booleanVal="1";
int index = word.indexOf(booleanVal);

    while(index >= 0) {

                if (cells[x][index]) {
                    g.fillRect(x * cellSize, index * cellSize, cellSize, cellSize);
                }

    index = word.indexOf(arrayStr, index+1);
}

Answer 5

By this your inner for loop with run n/4 times. It save time..

Pass a integer value for |cells[0].length/2|.

/********************* */

for (int y=0, oddOccurLeft = cells[0].length/2,oddOccurRight = cells[0].length/2, evenOccurLeft=cells[0].length/2,evenOccurRight=cells[0].length/2; ;y++ ) {

    if (cells[x][oddOccurLeft]) {
                    g.fillRect(x * cellSize, oddOccurLeft * cellSize, cellSize, cellSize);
    }

    if (cells[x][oddOccurRight]) {
                    g.fillRect(x * cellSize, oddOccurRight * cellSize, cellSize, cellSize);
    }

    if (cells[x][evenOccurLeft]) {
                    g.fillRect(x * cellSize, evenOccurLeft * cellSize, cellSize, cellSize);
    }

    if (cells[x][evenOccurRight]) {
                    g.fillRect(x * cellSize, evenOccurRight * cellSize, cellSize, cellSize);
    }

    ***if(oddOccurLeft<0 && oddOccurRight<0 && oddOccurRight>cells[0].length && evenOccurLeft>cells[0].length && evenOccurRight>cells[0].length)
        break;***

    oddOccurLeft=oddOccurLeft-y*2+1;
    oddOccurRight=oddOccurRight+y*2+1;

    evenOccurLeft=evenOccurLeft-y*2;
    evenOccurRight=evenOccurRight+y*2;

   }