Java - 避免矩阵迭代中的代码重复

Question

Suppose I have an int[size][size] matrix. I want to iterate through it like so:

01 02 03 04
08 07 06 05
09 10 11 12
16 15 14 13

Do I really have to say:

for (int y=0; y<size; y++) {
    int startIndex, endIndex, increment;
    boolean lessThan;
    if (y%2 == 0) {
        startIndex = 0;
        endIndex = size;
        lessThan = true;
        increment = 1;
    }
    else {
        startIndex = size-1;
        endIndex = -1;
        lessThan = false;
        increment = -1;
    }
    for (int x=startIndex; lessThan ? x<endIndex : x>endIndex; x+=increment) {
        // Process element
    }
}

to avoid doing this:

for (int y=0; y<size; y++) {
    if (y%2 == 0) {
        for (int x=0; x<size; x++) {
            // Process element
        }
    }
    else {
        for (int x=size-1; x>-1; x--) {
            // Process element
        }
    }
}

which is far nicer but repeats code. Is there a better way to structure this?

Answer 1

Create an interface to abstract the logic of processing the element:

interface ElementConsumer {
    void consume(int element);
}

Then use this abstraction in the loop:

void iterateMatrix(final int[][] matrix, final ElementConsumer consumer) {
    for (int y = 0; y < size; y++) {
        if (y % 2 == 0) {
            for (int x = 0; x < size; x++) {
                consumer.consume(matrix[x][y]);
            }
        } else {
            for (int x = size - 1; x > -1; x--) {
                consumer.consume(matrix[x][y]);
            }
        }
    }
}

Use the method thus:

iterateMatrix(matrix, new ElementConsumer() {
    @Override
    public void consume(int element) {
        //do stuff
    }
});

In Java 8 you can use the existing IntConsumer or LongConsumer functional interfaces and a lambda:

iterateMatrix(matrix, element -> /*doStuff*/);

Answer 2

One more approach to iterate through matrix:

for (int num = 0; num < maxX*maxY; ++num) { // num - element number
    // calc element coordinates
    int y = num / maxX;
    int x = num % maxX;
    if (y % 2 == 1)
       x = maxX - x;
    int elem = matrix[x][y];
    // process element
}

Answer 3

Can be accomplished this way too..

package com.kvvssut.misc;

public class TraverseAlternately {

    public static void main(String[] args) {
        traverseAlternately(new int[][]{{1,2,3,4},{8,7,6,5},{9,10,11,12},{16,15,14,13}});
    }

    private static void traverseAlternately(int[][] inputs) {
        int rows = inputs.length;
        if (rows > 0) {
            int i = -1;
            int j = 0;

            int cols = inputs[j].length;        // assuming all rows have same no.s of values

            while (true) {
                while (++i < cols) {        // traverses till the end of first row
                    System.out.println(inputs[j][i]);
                }
                if (j < rows - 1) {     // if reaches the no.s of rows, loop breaks
                    j++;
                } else {
                    break;
                }

                while (--i >= 0) {          // traverses backward to the zeroth location
                    System.out.println(inputs[j][i]);
                }
                if (j < rows - 1) {     // if reaches the no.s of rows, loop breaks
                    j++;
                } else {
                    break;
                }
            }
        }
    }

}

Answer 4

for (int y = 0; y < size; y++) {
    for (int x = (y%2 == 0 ? 0 : size - 1);
            (y%2 == 0 ? x < size : x >= 0);
            (y%2 == 0 ? x++ : x--)) {
        // Process element
    }
}