行列最大值、转置与格式化
安全地查找行列最大值（兼容不规则数组），并构建矩阵转置（矩形和不规则矩阵）。练习对齐打印。
行列最大值、转置与格式化 是 CoddyKit 上的免费 Java Academy 课时。 这是第 3 节课，共 6 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 6 节课。
行最大值
行最大值：通过遍历每行的元素一次，计算每行的最大值。
public class Main {
public static void main(String[] args) {
// Example jagged array
int[][] m = {
{1, 7, 3},
{4, 9, 2, 11},
{6}
};
int r = 1; // choose which row to check (row index 1 → {4, 9, 2, 11})
// Max of a single row r
int max = Integer.MIN_VALUE; // start with very small number
for (int c = 0; c < m[r].length; c = c + 1) {
if (m[r][c] > max) {
max = m[r][c]; // update if current value is larger
}
}
System.out.println("Max value in row " + r + " = " + max);
}
}
列最大值
对于锯齿数组中的列最大值：读取列 c 之前，先检查每一行的长度。
public class Main {
public static void main(String[] args) {
// Example jagged array (rows with different lengths)
int[][] m = {
{1, 7, 3},
{4, 9}, // shorter row (only 2 columns)
{6, 2, 11, 5} // longer row (4 columns)
};
int c = 2; // column index to check (3rd column)
// Max of column c across all rows
int colMax = Integer.MIN_VALUE;
for (int r = 0; r < m.length; r = r + 1) {
// Guard: only access if this row has column c
if (c < m[r].length) {
if (m[r][c] > colMax) {
colMax = m[r][c]; // update maximum
}
}
}
System.out.println("Max value in column " + c + " = " + colMax);
}
}
规则矩阵转置
转置（规则矩阵）：当所有行的长度都相同时，交换行和列。
public class Main {
public static void main(String[] args) {
// Example 2D rectangular matrix (3 rows × 2 columns)
int[][] m = {
{1, 2},
{3, 4},
{5, 6}
};
// Dimensions
int rows = m.length; // number of rows in m
int cols = m[0].length; // number of columns in m
// Transposed matrix (C × R)
int[][] t = new int[cols][rows];
// Fill transposed matrix
for (int r = 0; r < rows; r = r + 1) {
for (int c = 0; c < cols; c = c + 1) {
t[c][r] = m[r][c]; // swap row/column
}
}
// Print original matrix
System.out.println("Original matrix:");
for (int r = 0; r < rows; r++) {
for (int c = 0; c < cols; c++) {
System.out.print(m[r][c] + " ");
}
System.out.println();
}
// Print transposed matrix
System.out.println("Transposed matrix:");
for (int r = 0; r < t.length; r++) {
for (int c = 0; c < t[r].length; c++) {
System.out.print(t[r][c] + " ");
}
System.out.println();
}
}
}
锯齿数组转置
转置（锯齿数组）：将列创建为行，根据最长行的长度确定每行大小，并保护读取操作。
public class Main {
public static void main(String[] args) {
// Example jagged array (rows of different lengths)
int[][] m = {
{1, 2, 3},
{4, 5},
{6}
};
// 1) Find the maximum number of columns across all rows
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) {
if (m[r].length > maxCols) {
maxCols = m[r].length;
}
}
// 2) Create transpose: it will have maxCols rows
int[][] t = new int[maxCols][];
// 3) Fill the transposed matrix
for (int c = 0; c < maxCols; c = c + 1) {
// Each transposed row has as many elements as original rows
t[c] = new int[m.length];
for (int r = 0; r < m.length; r = r + 1) {
// If row is too short, pad with 0
t[c][r] = (c < m[r].length) ? m[r][c] : 0;
}
}
// Print original jagged array
System.out.println("Original jagged array:");
for (int r = 0; r < m.length; r++) {
for (int c = 0; c < m[r].length; c++) {
System.out.print(m[r][c] + " ");
}
System.out.println();
}
// Print transposed array
System.out.println("Jagged-safe transpose:");
for (int r = 0; r < t.length; r++) {
for (int c = 0; c < t[r].length; c++) {
System.out.print(t[r][c] + " ");
}
System.out.println();
}
}
}
格式化辅助方法
使用辅助方法计算列宽，并打印对齐的矩阵以便比较。
public class Main {
// Compute per-column widths for a (possibly jagged) 2D int array.
// For each column index c, we find the longest string length among m[r][c] (for rows that have that column).
static int[] widths(int[][] m) {
// 1) Find the maximum number of columns across all rows
int maxCols = 0;
for (int r = 0; r < m.length; r = r + 1) {
if (m[r].length > maxCols) maxCols = m[r].length;
}
// 2) Prepare width array (initialized to 0)
int[] w = new int[maxCols];
// 3) For each existing cell, compute the string length and keep the max per column
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;
}
}
// 4) Ensure each column has at least width 1
for (int c = 0; c < w.length; c = c + 1) {
if (w[c] < 1) w[c] = 1;
}
return w;
}
// Print a (possibly jagged) matrix so that each column is right-aligned using the widths[] computed above.
static void printAligned(int[][] m) {
int[] w = widths(m); // column widths
for (int r = 0; r < m.length; r = r + 1) {
String line = "";
for (int c = 0; c < m[r].length; c = c + 1) {
// Convert number to string
String s = Integer.toString(m[r][c]);
// Left-pad with spaces until it matches the target column width
while (s.length() < w[c]) s = " " + s;
// Append to the line; add a single space between columns (but not after the last one)
line = line + s + (c + 1 < m[r].length ? " " : "");
}
// Print the fully assembled row
System.out.println(line);
}
}
public static void main(String[] args) {
// Demo with a jagged matrix (different row lengths)
int[][] m = {
{1, 200, 3},
{45, 6},
{7, 89, 1000, 11}
};
System.out.println("Aligned output:");
printAligned(m);
}
}
转置演示
运行它：比较规则矩阵及其转置的对齐打印结果，然后查看锯齿矩阵、其列最大值和填充后的转置结果。
public class Main {
// Compute column maxima (jagged-safe)
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;
}
// Transpose rectangular
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 missing 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;
}
// Helpers
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);
}
}
public static void main(String[] args) {
// Rectangular example for transpose
int[][] rect = {
{1, 2, 3},
{4, 5, 6}
};
// Jagged example for maxima and jagged transpose
int[][] jag = {
{9, 12, 7},
{5},
{8, 10}
};
System.out.println("rect:");
printAligned(rect);
System.out.println("transpose(rect):");
printAligned(transposeRect(rect));
System.out.println("jag (jagged):");
printAligned(jag);
int[] cm = 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();
System.out.println("transpose(jag, padded):");
printAligned(transposeJagged(jag));
}
}
列最大值检查
快速检查：对于锯齿矩阵，如何计算列 c 的最大值？
回顾与下一步
回顾：您计算了行最大值和列最大值，转置了规则矩阵，并构建了带填充且能安全处理锯齿数组的转置结果。您还格式化了对齐输出。
常见问题解答
「行列最大值、转置与格式化」课时是免费的吗？
是的 — 「行列最大值、转置与格式化」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 6 节课。
「行列最大值、转置与格式化」这节课中我会学到什么？
安全地查找行列最大值（兼容不规则数组），并构建矩阵转置（矩形和不规则矩阵）。练习对齐打印。 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Java Academy 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 6 节。
「行列最大值、转置与格式化」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Java Academy 课中编写并运行代码吗？
能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。