Java 数组和二维数组 比较

测试结果：

100万次读写
所有结果只取创建该博客后，第一次运行(反正误差不大)

Random write by one dimensional: 64
Random write by tow dimensional: 83
Random read by one dimensional: 59
Random read by tow dimensional: 75

Process finished with exit code 0

测试数据：

PrintWriter out = new PrintWriter(new FileOutputStream("C:\\Users\\admin\\Desktop\\test.txt"));
        Random r = new Random();
        for (int i = 0; i < 1000000; i++) 
        	out.println(r.nextInt(4096) + " " + r.nextInt(4096) + " " + r.nextInt(Integer.MAX_VALUE));
        out.close();

测试用例：

import java.io.*;
import java.util.StringTokenizer;

public class Test {

    public static void main(String[] args) throws FileNotFoundException {
        InputReader in = new InputReader(new FileInputStream("C:\\Users\\admin\\Desktop\\test.txt"), " \n");
        Item[] items = new Item[1000000];
        for (int i = 0; i < 1000000; i++) items[i] = new Item(in.nextInt(), in.nextInt(), in.nextInt());
        {
            long outa = System.currentTimeMillis();
            int[] dp= new int[16777216];
            for (int k = 0, i, j, v; k < 1000000; k++) {
                i = items[k].i;
                j = items[k].j;
                v = items[k].v;
                dp[i * 4096 + j] = v;
            }
            long outb = System.currentTimeMillis();
            System.out.println("Random write by one dimensional: " + (outb - outa));
        }
        {
            long outa = System.currentTimeMillis();
            int[][] dp = new int[4096][4096];
            for (int k = 0, i, j, v; k < 1000000; k++) {
                i = items[k].i;
                j = items[k].j;
                v = items[k].v;
                dp[i][j] = v;
            }
            long outb = System.currentTimeMillis();
            System.out.println("Random write by tow dimensional: " + (outb - outa));
        }
        {
            long puta = System.currentTimeMillis();
            int[] dp= new int[16777216];
            for (int k = 0, i, j, v; k < 1000000; k++) {
                i = items[k].i;
                j = items[k].j;
                v = dp[i * 4096 + j];
            }
            long putb = System.currentTimeMillis();
            System.out.println("Random read by one dimensional: " + (putb - puta));
        }
        {
            long puta = System.currentTimeMillis();
            int[][] dp = new int[4096][4096];
            for (int k = 0, i, j, v; k < 1000000; k++) {
                i = items[k].i;
                j = items[k].j;
                v = dp[i][j];
            }
            long putb = System.currentTimeMillis();
            System.out.println("Random read by tow dimensional: " + (putb - puta));
        }
    }

    static class Item {
        int i, j, v;

        Item(int i, int j, int v) {
            this.i = i;
            this.j = j;
            this.v = v;
        }
    }

    static class InputReader {

        private BufferedReader read;
        private StringTokenizer tok;
        private String delimiters;

        InputReader(InputStream in) { this(in, " \n\t\r\f"); }

        InputReader(InputStream in, String delimiters) {
            this.read = new BufferedReader(new InputStreamReader(in));
            this.tok = new StringTokenizer("", this.delimiters = delimiters);
        }

        String next() {
            while (!tok.hasMoreTokens())
                try {
                    tok = new StringTokenizer(read.readLine(), delimiters);
                } catch (IOException e) { }
            return tok.nextToken();
        }

        int nextInt() { return Integer.parseInt(next(), 10); }
    }
}

没有写什么较为复杂的东西
所以直接放出结果和过程了

结论就是在Java里二维数组性能真的很差

有个很有意思的现象

当你对调测试模块的顺序时，结果会发生很大的改变

Random write by tow dimensional: 125
Random write by one dimensional: 60
Random read by tow dimensional: 83
Random read by one dimensional: 52

Process finished with exit code 0

有没有懂哥讲一下这个