我真的不知道如何描述我的问题，所以我只展示一个代码示例：
int[][][] mat;
int n;
int specificValue;
for (int i = 0; i < n; i++) {
if(mat[i][n-i][3] != specificValue) {
doStuff();
}
}
我在三维数组中查找整数值。对于每个字段，我必须使用其中一个：
- 从零到n的计数器
- 从n到0的计数器
- 固定值
所以我试着构建一个方法，让我不用为循环写这个大约20次，但我失败了，所以这就是我需要帮助的地方。我的想法是这样的：
search(Loop.UP, Loop.DOWN, Loop.FIXED);
其中"Loop"是一个枚举，表示我的一种可能性，但我不知道如何实现它，也不知道如果不硬编码每种可能的组合，这在Java中是否可行。
希望你能帮忙：(
好的，更具体一点。。。在我的设置中，我通过这个三维数组绘制了一个向量，一个特定的对角线，我想知道这个向量上有什么值，而这个向量上只有。
因为绘制这样一个向量的可能性不止一种，我希望有一个更通用的方法来获得这些值。我的搜索可能和一样简单
search(Loop.UP, Loop.FIXED, Loop.FIXED); // one plane
这将是一个简单的循环，有一个计数器，但也有
search(Loop.DOWN, Loop.UP, Loop.UP); // through all three planes
Path pathX = new Path.Up();
Path pathY = new Path.Down(n);
Path pathZ = new Path.Fixed(3);
for (int i = 0; i < n; i++) {
if(mat[pathX.pos(i)][pathY.pos(i)][pathZ.pos(i)] != specificValue) {
doStuff();
}
}
其中
public interface Path {
public int pos(int i);
public static class Up implements Path {
@Override public int pos(int i) { return i; }
}
public static class Down implements Path {
private int n;
public Down(int n) { this.n = n; }
@Override public int pos(int i) { return n - i - 1; }
}
public static class Fixed implements Path {
private int v;
public Down(int v) { this.v = v; }
@Override public int pos(int i) { return v; }
}
我没有使用枚举，因为Down依赖于n，Fixed依赖于某个值。
您可以使用索引列表。在Python中，它可能看起来像这样：
LOOP_UP = 20
LOOP_DOWN = LOOP_UP + 20
LOOP_FIXED = LOOP_DOWN + 20
def indexesOfLoopType(loopType, val):
if loopType == LOOP_UP:
return range(val)
if loopType == LOOP_DOWN:
return range(val, 0)
return [val] * val # make a list [val, val, val... ] of length val
def search(loopFirstIndex, loopSecondIndex, loopThirdIndex):
# use indexesOfLoopType() to get lists of indexes
# use those lists to iterate over mat
目前我能想到的最好的是：
static final int UP = -2, DOWN = -1;
static void loop1(int[][][] A, int t1, int t2, int t3) {
switch (t1) {
case UP:
for (int i = 0; i < A.length; i++)
loop2(A[i], t2, t3);
break;
case DOWN:
for (int i = A.length - 1; i >= 0; i--)
loop2(A[i], t2, t3);
break;
default:
loop2(A[t1], t2, t3);
}
}
static void loop2(int[][] A, int t2, int t3) {
switch (t2) {
case UP:
for (int i = 0; i < A.length; i++)
loop3(A[i], t3);
break;
case DOWN:
for (int i = A.length - 1; i >= 0; i--)
loop3(A[i], t3);
break;
default:
loop3(A[t2], t3);
}
}
static void loop3(int[] A, int t3) {
switch (t3) {
case UP:
for (int i = 0; i < A.length; i++) {
// Do something with A[i] here, such as...
System.out.println(A[i]);
}
break;
case DOWN:
for (int i = A.length - 1; i >= 0; i--) {
// Do something with A[i] here, such as...
System.out.println(A[i]);
}
break;
default:
// Do something with A[t3], such as...
System.out.println(A[t3]);
}
}
FIXED是唯一需要索引的选项，因此被编码为索引。UP和DOWN不是索引，因此它们使用负数进行编码。使用情况类似
public static void main(String[] args) {
int[][][] m = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };
loop1(m, DOWN, 1, UP);
}
对于我的System.out.println示例，输出将是
7
8
3
4