提前感谢您的帮助。
我有N 2d阵列具有完全相同的尺寸。我想将它们组合成一个2d数组。下面是一个只有2个2d数组的例子
array1 = [[1 2]
[3 4]
[5 6]]
array2 = [[7 8]
[9 1]
[2 3]]
result = [[1 2 7 8]
[3 4 9 1]
[5 6 2 3]]
最有效的方法是什么？这些阵列可能非常大，在某些情况下大约为20x10000。天真的方法是使用for循环，但这绝对是低效的，特别是因为我想要相当频繁地执行此操作。我怀疑我还可以在构建方法中使用一些java（可能是Arrays类？）。但是，有很多不同的方法可以做到这一点。考虑到这一点，最有效的方法是什么？
答案 0 :(得分：2)
数组可以解释为具有行和列的矩阵。目标是创建一个结果矩阵，其中每一行都是所有输入矩阵的相应行的串联。
对于每一行，这基本上可以分为两个步骤：
问题的核心是：将多个数组连接成一个数组的最有效方法是什么？ （反过来，可以被视为问题的概括：连接两个数组的最有效方法是什么？）
对于原始数组（例如，int[]数组），我可以想到三种基本方法：
使用System.arraycopy
private static int[] combineWithArraycopy(int[]... arrays)
{
// Assuming the same length for all arrays!
int length = arrays[0].length;
int result[] = new int[arrays.length * length];
for (int i = 0; i < arrays.length; i++)
{
System.arraycopy(arrays[i], 0, result, i * length, length);
}
return result;
}
使用IntBuffer
private static int[] combineWithBuffer(int[]... arrays)
{
// Assuming the same length for all arrays!
int length = arrays[0].length;
int result[] = new int[arrays.length * length];
IntBuffer buffer = IntBuffer.wrap(result);
for (int i = 0; i < arrays.length; i++)
{
buffer.put(arrays[i]);
}
return result;
}
使用IntStream
private static int[] combineWithStreams(int[] ... arrays)
{
return Stream.of(arrays).flatMapToInt(IntStream::of).toArray();
}
直观地说，我会把我的赌注押在System.arraycopy上。它基本上没有开销，归结为计算机可以执行的最基本操作之一 - 即：将内存从此处复制到那里。
旁注：在您的特定情况下，还有另一种可能的优化选项。即，为所有行并行调用此方法。但由于操作仅受内存限制，并且内存传输速度在很大程度上与CPU数量无关，因此这可能没有明显的影响。
这是一个比较三种方法的例子。
这不是一个完全可靠的基准。
但它考虑了一些微基准测试最佳实践，并粗略估计了人们可以期待的性能：
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class ArraycopyStreamPerformance
{
public static void main(String[] args)
{
basicTest();
int runs = 100;
int minNum = 2;
int maxNum = 8;
int minRows = 2;
int maxRows = 20;
int minCols = 100;
int maxCols = 10000;
for (int num = minNum; num <= maxNum; num *= 2)
{
for (int rows = minRows; rows <= maxRows; rows += 2)
{
for (int cols = minCols; cols <= maxCols; cols *= 10)
{
runTest(num, rows, cols, runs);
}
}
}
}
private static void runTest(int num, int rows, int cols, int runs)
{
int arrays[][][] = new int[num][rows][cols];
long before = 0;
long after = 0;
int blackHole = 0;
// arraycopy
before = System.nanoTime();
for (int i = 0; i < runs; i++)
{
int resultA[][] = combineRows(
ArraycopyStreamPerformance::combineWithArraycopy, arrays);
blackHole += resultA[0][0];
}
after = System.nanoTime();
System.out.printf(Locale.ENGLISH,
"%2d arrays, %3d rows, %6d cols, arraycopy : %8.3fms\n",
num, rows, cols, (after - before) / 1e6);
// arraycopy parallel
before = System.nanoTime();
for (int i = 0; i < runs; i++)
{
int resultA[][] = combineRowsParallel(
ArraycopyStreamPerformance::combineWithArraycopy, arrays);
blackHole += resultA[0][0];
}
after = System.nanoTime();
System.out.printf(Locale.ENGLISH,
"%2d arrays, %3d rows, %6d cols, arraycopy parallel: %8.3fms\n",
num, rows, cols, (after - before) / 1e6);
// buffer
before = System.nanoTime();
for (int i = 0; i < runs; i++)
{
int resultB[][] = combineRows(
ArraycopyStreamPerformance::combineWithBuffer, arrays);
blackHole += resultB[0][0];
}
after = System.nanoTime();
System.out.printf(Locale.ENGLISH,
"%2d arrays, %3d rows, %6d cols, buffer : %8.3fms\n",
num, rows, cols, (after - before) / 1e6);
// buffer parallel
before = System.nanoTime();
for (int i = 0; i < runs; i++)
{
int resultB[][] = combineRowsParallel(
ArraycopyStreamPerformance::combineWithBuffer, arrays);
blackHole += resultB[0][0];
}
after = System.nanoTime();
System.out.printf(Locale.ENGLISH,
"%2d arrays, %3d rows, %6d cols, buffer parallel: %8.3fms\n",
num, rows, cols, (after - before) / 1e6);
// streams
before = System.nanoTime();
for (int i = 0; i < runs; i++)
{
int resultC[][] = combineRows(
ArraycopyStreamPerformance::combineWithStreams, arrays);
blackHole += resultC[0][0];
}
after = System.nanoTime();
System.out.printf(Locale.ENGLISH,
"%2d arrays, %3d rows, %6d cols, stream : %8.3fms (" +
blackHole + ")\n", num, rows, cols, (after - before) / 1e6);
}
private static void basicTest()
{
int array1[][] =
{
{ 1, 2 },
{ 3, 4 },
{ 5, 6 }
};
int array2[][] =
{
{ 7, 8 },
{ 9, 1 },
{ 2, 3 }
};
int result[][] =
{
{ 1, 2, 7, 8 },
{ 3, 4, 9, 1 },
{ 5, 6, 2, 3 }
};
System.out.println(Arrays.deepToString(result));
int resultA[][] = combineRows(
ArraycopyStreamPerformance::combineWithArraycopy, array1, array2);
System.out.println(Arrays.deepToString(resultA));
int resultB[][] = combineRows(
ArraycopyStreamPerformance::combineWithBuffer, array1, array2);
System.out.println(Arrays.deepToString(resultB));
int resultC[][] = combineRows(
ArraycopyStreamPerformance::combineWithStreams, array1, array2);
System.out.println(Arrays.deepToString(resultC));
}
private static int[][] selectRows(int row, int[][]... arrays)
{
int result[][] = new int[arrays.length][];
for (int j = 0; j < arrays.length; j++)
{
result[j] = arrays[j][row];
}
return result;
}
private static int[][] combineRows(
Function<int[][], int[]> mergeFunction, int[][]... arrays)
{
int rows = arrays[0].length;
int result[][] = new int[rows][];
for (int i = 0; i < rows; i++)
{
result[i] = mergeFunction.apply(selectRows(i, arrays));
}
return result;
}
private static int[] combineWithArraycopy(int[]... arrays)
{
// Assuming the same length for all arrays!
int length = arrays[0].length;
int result[] = new int[arrays.length * length];
for (int i = 0; i < arrays.length; i++)
{
System.arraycopy(arrays[i], 0, result, i * length, length);
}
return result;
}
private static int[] combineWithBuffer(int[]... arrays)
{
// Assuming the same length for all arrays!
int length = arrays[0].length;
int result[] = new int[arrays.length * length];
IntBuffer buffer = IntBuffer.wrap(result);
for (int i = 0; i < arrays.length; i++)
{
buffer.put(arrays[i]);
}
return result;
}
private static int[] combineWithStreams(int[] ... arrays)
{
return Stream.of(arrays).flatMapToInt(IntStream::of).toArray();
}
private static final ExecutorService EXECUTOR_SERVICE =
createFixedTimeoutExecutorService(
Runtime.getRuntime().availableProcessors(), 5, TimeUnit.SECONDS);
public static ExecutorService createFixedTimeoutExecutorService(
int poolSize, long keepAliveTime, TimeUnit timeUnit)
{
ThreadPoolExecutor e =
new ThreadPoolExecutor(poolSize, poolSize,
keepAliveTime, timeUnit, new LinkedBlockingQueue<Runnable>());
e.allowCoreThreadTimeOut(true);
return e;
}
private static int[][] combineRowsParallel(
Function<int[][], int[]> mergeFunction, int[][]... arrays)
{
int rows = arrays[0].length;
int result[][] = new int[rows][];
List<Callable<Object>> tasks = new ArrayList<Callable<Object>>();
for (int i = 0; i < rows; i++)
{
int index = i;
tasks.add(Executors.callable(() ->
{
result[index] = mergeFunction.apply(selectRows(index, arrays));
}));
}
try
{
EXECUTOR_SERVICE.invokeAll(tasks);
}
catch (InterruptedException e)
{
Thread.currentThread().interrupt();
}
return result;
}
}
我（旧的，慢的）PC上的输出是这样的：
...
8 arrays, 20 rows, 10000 cols, arraycopy : 354.977ms
8 arrays, 20 rows, 10000 cols, arraycopy parallel: 327.749ms
8 arrays, 20 rows, 10000 cols, buffer : 328.717ms
8 arrays, 20 rows, 10000 cols, buffer parallel: 312.522ms
8 arrays, 20 rows, 10000 cols, stream : 2044.017ms (0)
显示并行化不会带来值得努力的加速，并且通常，基于arraycopy和IntBuffer的方法具有大致相同的性能。
YMMV。如果有人有耐心为此进行JMH运行，我会很感激。
答案 1 :(得分：0)
试试这个。
static int[][] append(int[][]... matrices) {
int size = matrices.length;
int rows = matrices[0].length;
int cols = matrices[0][0].length;
int[][] result = new int[rows][cols * size];
for (int i = 0; i < rows; ++i)
for (int j = 0, k = 0; j < size; ++j, k += cols)
System.arraycopy(matrices[j][i], 0, result[i], k, cols);
return result;
}
和
int[][] a = {{1, 2}, {3, 4}, {5, 6}};
int[][] b = {{7, 8}, {9, 1}, {2, 3}};
int[][] result = append(a, b);
for (int[] e : result)
System.out.println(Arrays.toString(e));
结果：
[1, 2, 7, 8]
[3, 4, 9, 1]
[5, 6, 2, 3]
答案 2 :(得分：-1)
在我看来，使用带有这种数组的for循环比使用流或列表更好。
但这只是我的意见......
我是多线程的（由于线程创建开销，这对小型数组来说太过分了）。即使对于大小为20 * 10000的数组，多线程也可能是一种过度杀伤;但是，如果需要多次执行，则可以使用executorService。但这取决于你的需求......
以下是一个例子：
public static void main(String[] args) {
test(100, 20, 3);
test(7, 3, 4);
test(3,7,4);
}
private static void test(int outerSize, int innerSize, int numberOfArrays) {
int[][][] arrays = new int[numberOfArrays][outerSize][innerSize];
int[][] resultArray;
int counter = 0;
System.out.println("Testing " + numberOfArrays + " arrays, " + outerSize + " by " + innerSize);
for (int arrayIndex = 0; arrayIndex < numberOfArrays; arrayIndex++)
for (int outerIndex = 0; outerIndex < outerSize; outerIndex++) {
for (int innerIndex = 0; innerIndex < innerSize; innerIndex++) {
arrays[arrayIndex][outerIndex][innerIndex] = counter++;
}
}
// Change number of threads here;
resultArray = new ArrayCombiner(5, arrays).combine();
System.out.println(Arrays.deepToString(resultArray));
}
static class ArrayCombiner {
private final int[][][] sources;
private final int[][] resultArray;
private final int innerSourceLength, outerSourceLength, numberOfThreads;
public ArrayCombiner(int numberOfThreads, int[][]... sources) {
this.sources = sources;
this.numberOfThreads = numberOfThreads;
resultArray = new int[outerSourceLength = sources[0].length][(innerSourceLength = sources[0][0].length)
* sources.length];
}
public int[][] combine() {
if (numberOfThreads <= 1) {
combinePortion(0, outerSourceLength);
} else {
Thread[] threads = new Thread[numberOfThreads];
for (int i = 0; i < numberOfThreads; i++) {
(threads[(int) i] = new Thread(runnableToCombinePortion(i))).start();
}
for (int i = 0; i < numberOfThreads; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
return resultArray;
}
private Runnable runnableToCombinePortion(int threadIndex) {
int outerFrom = (int) ((float) threadIndex / numberOfThreads * outerSourceLength),
outerTo = (int) ((float) (1 + threadIndex) / numberOfThreads * outerSourceLength);
return () -> {
combinePortion(outerFrom, outerTo);
};
}
private void combinePortion(int outerFrom, int outerTo) {
for (int outerIndex = outerFrom; outerIndex < outerTo; outerIndex++) {
for (int sourceIndex = 0; sourceIndex < sources.length; sourceIndex++) {
System.arraycopy(sources[sourceIndex][outerIndex], 0, resultArray[outerIndex],
sourceIndex * innerSourceLength, innerSourceLength);
}
}
}
}