Resize primitive 2D array

Question

Given the following two-dimensional (2D) array of integers, how can I resize the array similar to Numpy's resize() function for Python?

matrix = [
    [ 1, 2, 3 ],
    [ 4, 5, 6 ],
    [ 7, 8, 9 ]
]

Code

public class MatrixUtils {
    public static void main(String[] args) {
        int[][] matrix = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        System.out.println(formatMatrix(matrix));
        System.out.println(formatMatrix(resize(matrix, 4, 4)));
        System.out.println(formatMatrix(resize(matrix, 2, 2)));
    }

    public static int[][] resize(int[][] matrix, int w, int h) {
        return addRows(addCols(matrix, w-getWidth(matrix)), h-getHeight(matrix));
    }
}

With System.arraycopy() , you can modify the length of an Array by reserving a new place in memory and changing the pointer.

System.arraycopy(matrix, 0, copy, 0, n > 0 ? oldHeight : newHeight);

Expected Output

1,2,3
4,5,6
7,8,9

1,2,3,0
4,5,6,0
7,8,9,0
0,0,0,0

1,2
4,5

Answer 1

Using the following code below, you can alter the dimensions of the array. There are also several formatting functions to configure the separator tokens.

public class MatrixUtils {
       public static void main(String[] args) {
              int[][] matrix = null;

              matrix = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

              System.out.println(formatMatrix(matrix, "=", "-") + '\n');
              System.out.println(formatMatrix(matrix) + '\n');
              System.out.println(formatMatrix(resize(matrix, 4, 4)) + '\n');
              System.out.println(formatMatrix(resize(matrix, 2, 2)) + '\n');
              System.out.println(formatMatrix(resize(matrix, 10, 15)) + '\n');
       }

       public static final int getWidth(final int[][] matrix) {
              int max = 0;
              if (matrix.length > 0) {
                     max = matrix[0].length;
                     if (matrix.length > 1) {
                           for (int i = 1; i < matrix.length; i++) {
                                  if (matrix[i].length > max) {
                                         max = matrix[i].length;
                                  }
                           }
                     }
              }
              return max;
       }

       public static final int getHeight(final int[][] matrix) {
              return matrix.length;
       }

       public static int[][] resize(final int[][] matrix, final int w, final int h) {
              int width = getWidth(matrix);
              int height = getHeight(matrix);
              return addRows(addCols(matrix, w - width), h - height);
       }

       private static int[][] addRows(final int[][] matrix, final int n) {
              if (n == 0) {
                     return matrix;
              }
              int oldHeight = matrix.length;
              int newHeight = oldHeight + n;
              int width = getWidth(matrix);
              int[][] copy = new int[newHeight][];
              System.arraycopy(matrix, 0, copy, 0, n > 0 ? oldHeight : newHeight);
              for (int i = oldHeight; i < newHeight; i++) {
                     copy[i] = new int[width];
              }
              return copy;
       }

       private static int[][] addCols(final int[][] matrix, final int n) {
              if (n == 0) {
                     return matrix;
              }
              int oldWidth = getWidth(matrix);
              int newWidth = oldWidth + n;
              int height = matrix.length;
              int[][] copy = new int[height][newWidth];
              for (int i = 0; i < height; i++) {
                     copy[i] = new int[newWidth];
                     System.arraycopy(matrix[i], 0, copy[i], 0, n > 0 ? oldWidth
                                  : newWidth);
              }
              return copy;
       }

       public static String formatMatrix(final int[][] matrix) {
              return formatMatrix(matrix, "\n", ",").toString();
       }


       public static String formatMatrix(final int[][] matrix, String vSep, String hSep) {
              return join(new StringBuffer(), matrix, vSep, hSep).toString();
       }

       public static StringBuffer join(final int[][] arr, String vSep, String hSep) {
              return join(new StringBuffer(), arr, vSep, hSep);
       }

       public static StringBuffer join(final int[] arr, String sep) {
              return join(new StringBuffer(), arr, sep);
       }

       protected static StringBuffer join(StringBuffer buff, final int[][] arr, String vSep, String hSep) {
              if (arr.length > 0) {
                     join(buff, arr[0], hSep);
                     for (int i = 1; i < arr.length; i++) {
                           join(buff.append(vSep), arr[i], hSep);
                     }
              }
              return buff;
       }

       protected static StringBuffer join(StringBuffer buff, int[] arr, String sep) {
              if (arr.length > 0) {
                     buff.append(arr[0]);
                     for (int i = 1; i < arr.length; i++) {
                           buff.append(sep).append(arr[i]);
                     }
              }
              return buff;
       }
}

Output

1-2-3=4-5-6=7-8-9

1,2,3
4,5,6
7,8,9

1,2,3,0
4,5,6,0
7,8,9,0
0,0,0,0

1,2
4,5

1,2,3,0,0,0,0,0,0,0
4,5,6,0,0,0,0,0,0,0
7,8,9,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0
0,0,0,0,0,0,0,0,0,0

Answer 2

static int[][] resize(int[][] matrix, int w, int h) {
    int[][] temp = new int[h][w];
    h = Math.min(h, matrix.length);
    w = Math.min(w, matrix[0].length);
    for (int i = 0; i < h; i++)
        System.arraycopy(matrix[i], 0, temp[i], 0, w);
    return temp;
}