Bereinigung und Validierung von 2D-Daten
Bereinigen und validieren Sie zweidimensionale Integer-Daten: Fangen Sie null-Zeilen ab, prüfen Sie Indizes auf gültige Grenzen, begrenzen Sie Werte außerhalb des zulässigen Bereichs, vereinheitlichen Sie gezackte Formen und erstellen Sie Validierungsberichte.
Bereinigung und Validierung von 2D-Daten ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 6 von 6. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 6 Lektionen.
Warum 2D-Daten bereinigen?
Ziel: 2D-Ganzzahldaten sicher und konsistent machen. Wir werden: (1) Nullzeilen abfangen, (2) die Grenzen für jede Zeile prüfen, (3) Werte auf einen gültigen Bereich begrenzen, (4) unregelmäßige Formen bei Bedarf normalisieren und (5) einen Validierungsbericht erstellen.
Nullwerte & Grenzen
Schritt 1: Ersetzen Sie Nullzeilen durch leere Arrays und kopieren Sie Werte defensiv. Stellen Sie eine inBounds-Hilfsmethode bereit, um die Zeilenlängen einzeln zu prüfen.
public class Main {
// Make a defensive copy of m. Replace null rows with empty arrays.
static int[][] copyOrEmpty(int[][] m) {
if (m == null) return new int[0][0];
int[][] out = new int[m.length][];
for (int r = 0; r < m.length; r = r + 1) {
if (m[r] == null) {
out[r] = new int[0];
} else {
out[r] = new int[m[r].length];
for (int c = 0; c < m[r].length; c = c + 1) out[r][c] = m[r][c];
}
}
return out;
}
// Safe bounds check for jagged matrices
static boolean inBounds(int[][] m, int r, int c) {
return m != null && r >= 0 && r < m.length && m[r] != null && c >= 0 && c < m[r].length;
}
public static void main(String[] args) {
int[][] raw = new int[][] { null, {1, 2, 3}, {4} };
int[][] cleaned = copyOrEmpty(raw);
System.out.println("rows = " + cleaned.length);
for (int r = 0; r < cleaned.length; r = r + 1) System.out.println("row " + r + " len = " + cleaned[r].length);
System.out.println("inBounds(1,2) = " + inBounds(cleaned, 1, 2)); // true
System.out.println("inBounds(2,2) = " + inBounds(cleaned, 2, 2)); // false
}
}
Werte begrenzen
Schritt 2: Begrenzen Sie Werte auf einen gültigen Bereich, zum Beispiel 0–100. Ungültige negative Werte werden zu 0, zu große Werte zu 100.
public class Main {
static int clamp(int v, int lo, int hi) { if (v < lo) return lo; if (v > hi) return hi; return v; }
static void clampAll(int[][] m, int lo, int hi) {
if (m == null) return;
for (int r = 0; r < m.length; r = r + 1) {
if (m[r] == null) continue;
for (int c = 0; c < m[r].length; c = c + 1) m[r][c] = clamp(m[r][c], lo, hi);
}
}
static void print(int[][] m) {
for (int r = 0; r < m.length; r = r + 1) {
if (m[r] == null) { System.out.println("<null row>"); continue; }
for (int c = 0; c < m[r].length; c = c + 1) System.out.print(m[r][c] + (c + 1 < m[r].length ? " " : ""));
System.out.println();
}
}
public static void main(String[] args) {
int[][] m = { { -5, 101, 50 }, null, { 200 } };
System.out.println("before clamp:");
print(m);
clampAll(m, 0, 100);
System.out.println("after clamp [0..100]:");
print(m);
}
}
Form normalisieren
Schritt 3: Normalisieren Sie die Daten auf eine rechteckige Form, indem Sie jede zu kurze oder nullte Zeile mit einem Füllwert, zum Beispiel 0, bis zur Länge der längsten Zeile auffüllen.
public class Main {
static int[][] padToMaxCols(int[][] m, int pad) {
if (m == null) return new int[0][0];
int rows = m.length;
int maxCols = 0;
for (int r = 0; r < rows; r = r + 1) if (m[r] != null && m[r].length > maxCols) maxCols = m[r].length;
int[][] out = new int[rows][maxCols];
for (int r = 0; r < rows; r = r + 1) {
int cols = (m[r] == null) ? 0 : m[r].length;
for (int c = 0; c < cols; c = c + 1) out[r][c] = m[r][c];
for (int c = cols; c < maxCols; c = c + 1) out[r][c] = pad; // pad missing cells
}
return out;
}
static void print(int[][] x) {
for (int r = 0; r < x.length; r = r + 1) {
for (int c = 0; c < x[r].length; c = c + 1) System.out.print(x[r][c] + (c + 1 < x[r].length ? " " : ""));
System.out.println();
}
}
public static void main(String[] args) {
int[][] jag = { {1, 23, 456}, {7, 8}, null, {90} };
int[][] rect = padToMaxCols(jag, 0);
print(rect);
}
}
Validierungsbericht
Schritt 4: Erstellen Sie einen Validierungsbericht: Zählen Sie negative Werte, zu große Werte, Nullzeilen und alle besuchten Zellen.
public class Main {
static class Report { int negatives; int overMax; int nullRows; int cells; }
static Report validate(int[][] m, int hi) {
Report r = new Report();
if (m == null) return r;
for (int i = 0; i < m.length; i = i + 1) {
if (m[i] == null) { r.nullRows = r.nullRows + 1; continue; }
for (int j = 0; j < m[i].length; j = j + 1) {
int v = m[i][j];
r.cells = r.cells + 1;
if (v < 0) r.negatives = r.negatives + 1;
if (v > hi) r.overMax = r.overMax + 1;
}
}
return r;
}
public static void main(String[] args) {
int[][] m = { { -5, 101, 50 }, null, { 200 } };
Report r = validate(m, 100);
System.out.println("cells=" + r.cells + ", negatives=" + r.negatives + ", overMax=" + r.overMax + ", nullRows=" + r.nullRows);
}
}
Ausgabe ohne Nullzeilen
Schritt 5: Stellen Sie eine ausgerichtete Ausgabe bereit, die Nullzeilen problemlos überspringt und die Länge jeder Zeile berücksichtigt.
public class Main {
static boolean inBounds(int[][] m, int r, int c) {
return m != null && r >= 0 && r < m.length && m[r] != null && c >= 0 && c < m[r].length;
}
static int[] widths(int[][] m) {
int maxCols = 0; if (m == null) return new int[0];
for (int r = 0; r < m.length; r = r + 1) if (m[r] != null && m[r].length > maxCols) maxCols = m[r].length;
int[] w = new int[maxCols];
for (int r = 0; r < m.length; r = r + 1) {
if (m[r] == null) continue;
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 printAlignedSkipNull(int[][] m) {
int[] w = widths(m);
for (int r = 0; r < m.length; r = r + 1) {
if (m[r] == null) { System.out.println("<skipped null row>"); continue; }
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) {
int[][] m = { { 1, 200, -3 }, null, { 45 } };
printAlignedSkipNull(m);
}
}
Prüfung des sicheren Zugriffs
Kurzprüfung: Wie greifen Sie sicher auf m[r][c] in möglicherweise unregelmäßigen Daten zu?
Zusammenfassung & Nächstes
Zusammenfassung: Sie haben Daten defensiv kopiert, Indizes abgesichert, Werte begrenzt, unregelmäßige Formen normalisiert und Validierungszusammenfassungen erstellt. Diese Bausteine machen spätere 2D-Algorithmen robust.
Häufig gestellte Fragen
Ist die Lektion „Bereinigung und Validierung von 2D-Daten“ kostenlos?
Ja — der vollständige Text von „Bereinigung und Validierung von 2D-Daten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 6 Lektionen.
Was lerne ich in „Bereinigung und Validierung von 2D-Daten“?
Bereinigen und validieren Sie zweidimensionale Integer-Daten: Fangen Sie null-Zeilen ab, prüfen Sie Indizes auf gültige Grenzen, begrenzen Sie Werte außerhalb des zulässigen Bereichs, vereinheitliche… Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 6 von 6.
Wie lange dauert die Lektion „Bereinigung und Validierung von 2D-Daten“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Grundlagen zweidimensionaler Arrays und verschachtelte Iteration
- Gezackte Arrays und Tabellenformatierung
- Zeilen-/Spaltenmaxima, Transponieren und Formatierung
- 2D-Mini-Projekt: Notenverwaltung
- 2D-Hilfsfunktionen als Hilfsklasse (Refactoring)
- Bereinigung und Validierung von 2D-Daten