Java Academy · 课时

将二维工具提取为辅助类（重构）

将重复的二维逻辑重构为可复用的辅助工具。提供用于计算宽度、对齐打印、平均值、最大值和转置的静态工具方法。在小型示例中使用该辅助工具。

将二维工具提取为辅助类（重构） 是 CoddyKit 上的免费 Java Academy 课时。这是第 5 节课，共 6 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 6 节课。

为什么要重构

为什么要重构为辅助工具？避免复制粘贴，保持唯一事实来源，并让后续课程更简单。我们将创建一个 GradeUtil 辅助类，其中包含用于宽度、对齐打印、平均值、最大值和转置的静态方法。

辅助类骨架 + 打印

创建一个包含宽度和 printAligned 的静态 GradeUtil。然后在 main 中调用 GradeUtil.printAligned(m)，即可打印任意列对齐的锯齿矩阵。

public class Main {
  // Static helper with reusable utilities for 2D int matrices
  static class GradeUtil {
    // Compute per-column widths (jagged-aware)
    static int[] widths(int[][] m) {
      int maxCols = 0;
      for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
      int[] w = new int[maxCols];
      for (int r = 0; r < m.length; r = r + 1) {
        for (int c = 0; c < m[r].length; c = c + 1) {
          int len = Integer.toString(m[r][c]).length();
          if (len > w[c]) w[c] = len;
        }
      }
      for (int c = 0; c < w.length; c = c + 1) if (w[c] < 1) w[c] = 1;
      return w;
    }

    // Print matrix with aligned columns
    static void printAligned(int[][] m) {
      int[] w = widths(m);
      for (int r = 0; r < m.length; r = r + 1) {
        String line = "";
        for (int c = 0; c < m[r].length; c = c + 1) {
          String s = Integer.toString(m[r][c]);
          while (s.length() < w[c]) s = " " + s;
          line = line + s + (c + 1 < m[r].length ? " " : "");
        }
        System.out.println(line);
      }
    }
  }

  public static void main(String[] args) {
    // Demo: build a small jagged matrix and print it via the helper
    int[][] m = {
      {1, 23, 456},
      {7, 8},
      {90, 12, 3, 4}
    };
    System.out.println("Aligned print via GradeUtil:");
    GradeUtil.printAligned(m);
  }
}

平均值辅助方法

将 rowAverage 和 colAverage 添加到辅助类中，并在 main 中调用它们。列平均值必须检查每一行的长度，以确保对锯齿矩阵安全。

public class Main {
  static class GradeUtil {
    static double rowAverage(int[][] g, int r) {
      int sum = 0;
      for (int c = 0; c < g[r].length; c = c + 1) sum = sum + g[r][c];
      return (double) sum / g[r].length;
    }
    static double colAverage(int[][] g, int c) {
      int sum = 0;
      int count = 0;
      for (int r = 0; r < g.length; r = r + 1) {
        if (c < g[r].length) { sum = sum + g[r][c]; count = count + 1; }
      }
      return (double) sum / count;
    }
  }

  public static void main(String[] args) {
    int[][] g = {
      {78, 85, 90, 88, 92},
      {95, 91, 89, 93, 87},
      {60, 72, 70, 68, 75},
      {88, 84, 79, 85, 90}
    };

    // Use helper to compute row averages
    for (int r = 0; r < g.length; r = r + 1) {
      double avg = GradeUtil.rowAverage(g, r);
      System.out.println("student " + r + " avg = " + String.format("%.2f", avg));
    }

    // Use helper to compute column averages
    for (int c = 0; c < g[0].length; c = c + 1) {
      double avg = GradeUtil.colAverage(g, c);
      System.out.println("assignment " + c + " avg = " + String.format("%.2f", avg));
    }
  }
}

转置辅助方法

为矩形矩阵和锯齿矩阵实现转置。锯齿版本会为每个列索引创建一行，并用零填充缺失的元素。

public class Main {
  static class GradeUtil {
    // Transpose rectangular matrix (R x C) -> (C x R)
    static int[][] transposeRect(int[][] m) {
      int rows = m.length;
      int cols = m[0].length;
      int[][] t = new int[cols][rows];
      for (int r = 0; r < rows; r = r + 1) {
        for (int c = 0; c < cols; c = c + 1) t[c][r] = m[r][c];
      }
      return t;
    }
    // Jagged-safe transpose (pads with 0)
    static int[][] transposeJagged(int[][] m) {
      int maxCols = 0;
      for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
      int[][] t = new int[maxCols][];
      for (int c = 0; c < maxCols; c = c + 1) {
        t[c] = new int[m.length];
        for (int r = 0; r < m.length; r = r + 1) t[c][r] = (c < m[r].length) ? m[r][c] : 0;
      }
      return t;
    }
  }

  public static void main(String[] args) {
    int[][] rect = {
      {1, 2, 3},
      {4, 5, 6}
    };
    int[][] t = GradeUtil.transposeRect(rect);
    System.out.println("t[0][1] should be 2: " + t[0][1]);

    int[][] jag = {
      {9, 12, 7},
      {5},
      {8, 10}
    };
    int[][] tj = GradeUtil.transposeJagged(jag);
    System.out.println("tj[1][0] should be 12: " + tj[1][0]);
  }
}

列最大值辅助方法

提供 colMaxima 来计算每列的最大值，并安全处理锯齿行。使用已见标志，避免列为空时产生错误的最小值。

public class Main {
  static class GradeUtil {
    // Column maxima for a jagged matrix
    static int[] colMaxima(int[][] m) {
      int maxCols = 0;
      for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
      int[] max = new int[maxCols];
      for (int c = 0; c < maxCols; c = c + 1) {
        int best = Integer.MIN_VALUE;
        boolean seen = false;
        for (int r = 0; r < m.length; r = r + 1) {
          if (c < m[r].length) {
            if (!seen || m[r][c] > best) { best = m[r][c]; seen = true; }
          }
        }
        max[c] = seen ? best : 0;
      }
      return max;
    }
  }

  public static void main(String[] args) {
    int[][] jag = {
      {9, 12, 7},
      {5},
      {8, 10}
    };
    int[] cm = GradeUtil.colMaxima(jag);
    System.out.print("col maxima: ");
    for (int i = 0; i < cm.length; i = i + 1) System.out.print(cm[i] + (i + 1 < cm.length ? " " : ""));
    System.out.println();
  }
}

汇总所有工具

将所有工具组合到一个辅助类中，并从单个 main 驱动它们：打印、计算平均值、转置以及计算列最大值。这是您为后续课程准备的可复用工具集。

public class Main {
  static class GradeUtil {
    static int[] widths(int[][] m) {
      int maxCols = 0;
      for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
      int[] w = new int[maxCols];
      for (int r = 0; r < m.length; r = r + 1) {
        for (int c = 0; c < m[r].length; c = c + 1) {
          int len = Integer.toString(m[r][c]).length();
          if (len > w[c]) w[c] = len;
        }
      }
      for (int c = 0; c < w.length; c = c + 1) if (w[c] < 1) w[c] = 1;
      return w;
    }
    static void printAligned(int[][] m) {
      int[] w = widths(m);
      for (int r = 0; r < m.length; r = r + 1) {
        String line = "";
        for (int c = 0; c < m[r].length; c = c + 1) {
          String s = Integer.toString(m[r][c]);
          while (s.length() < w[c]) s = " " + s;
          line = line + s + (c + 1 < m[r].length ? " " : "");
        }
        System.out.println(line);
      }
    }
    static double rowAverage(int[][] g, int r) {
      int sum = 0; for (int c = 0; c < g[r].length; c = c + 1) sum = sum + g[r][c];
      return (double) sum / g[r].length;
    }
    static double colAverage(int[][] g, int c) {
      int sum = 0; int count = 0;
      for (int r = 0; r < g.length; r = r + 1) { if (c < g[r].length) { sum = sum + g[r][c]; count = count + 1; } }
      return (double) sum / count;
    }
    static int[][] transposeRect(int[][] m) {
      int rows = m.length; int cols = m[0].length; int[][] t = new int[cols][rows];
      for (int r = 0; r < rows; r = r + 1) for (int c = 0; c < cols; c = c + 1) t[c][r] = m[r][c];
      return t;
    }
    static int[][] transposeJagged(int[][] m) {
      int maxCols = 0; for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
      int[][] t = new int[maxCols][];
      for (int c = 0; c < maxCols; c = c + 1) { t[c] = new int[m.length]; for (int r = 0; r < m.length; r = r + 1) t[c][r] = (c < m[r].length) ? m[r][c] : 0; }
      return t;
    }
    static int[] colMaxima(int[][] m) {
      int maxCols = 0; for (int r = 0; r < m.length; r = r + 1) if (m[r].length > maxCols) maxCols = m[r].length;
      int[] max = new int[maxCols];
      for (int c = 0; c < maxCols; c = c + 1) {
        int best = Integer.MIN_VALUE; boolean seen = false;
        for (int r = 0; r < m.length; r = r + 1) if (c < m[r].length) { if (!seen || m[r][c] > best) { best = m[r][c]; seen = true; } }
        max[c] = seen ? best : 0;
      }
      return max;
    }
  }

  public static void main(String[] args) {
    int[][] g = {
      {78, 85, 90, 88, 92},
      {95, 91, 89, 93, 87},
      {60, 72, 70, 68, 75},
      {88, 84, 79, 85, 90}
    };

    System.out.println("Original gradebook:");
    GradeUtil.printAligned(g);

    System.out.println("Row averages:");
    for (int r = 0; r < g.length; r = r + 1) System.out.println(r + ": " + String.format("%.2f", GradeUtil.rowAverage(g, r)));

    System.out.println("Column averages:");
    for (int c = 0; c < g[0].length; c = c + 1) System.out.println(c + ": " + String.format("%.2f", GradeUtil.colAverage(g, c)));

    System.out.println("Transpose (rect):");
    GradeUtil.printAligned(GradeUtil.transposeRect(g));

    System.out.println("Column maxima:");
    int[] cm = GradeUtil.colMaxima(g);
    for (int i = 0; i < cm.length; i = i + 1) System.out.print(cm[i] + (i + 1 < cm.length ? " " : ""));
    System.out.println();
  }
}

静态调用检查

快速检查：如何调用一个用于打印矩阵的静态辅助方法？

回顾与下一步

回顾：您将常见的二维操作重构到了 GradeUtil 辅助类中，并在多个演示中使用了它。这样可以让各课中的代码保持简洁、易读且一致。

常见问题解答

「将二维工具提取为辅助类（重构）」课时是免费的吗？

是的 — 「将二维工具提取为辅助类（重构）」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 6 节课。

「将二维工具提取为辅助类（重构）」这节课中我会学到什么？

将重复的二维逻辑重构为可复用的辅助工具。提供用于计算宽度、对齐打印、平均值、最大值和转置的静态工具方法。在小型示例中使用该辅助工具。你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 5 节课，共 6 节。

「将二维工具提取为辅助类（重构）」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Java Academy