Rensning och validering av 2D-data
Rensa och validera 2D-heltalsdata: hantera null-rader, kontrollera indexgränser, begränsa värden utanför intervallet, normalisera ojämna former och skapa valideringsrapporter.
Rensning och validering av 2D-data är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 6 av 6. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 6 lektioner.
Varför rensa 2D-data?
Mål: Gör 2D-heltalsdata säkra och konsekventa. Vi kommer att: (1) hantera null-rader, (2) kontrollera gränser per rad, (3) begränsa värden till ett giltigt intervall, (4) normalisera ojämna former vid behov och (5) skapa en valideringsrapport.
Nullvärden och gränser
Steg 1: Ersätt null-rader med tomma arrayer och kopiera värden på ett defensivt sätt. Skapa en inBounds-hjälpmetod för att kontrollera gränser utifrån varje rads längd.
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
}
}
Begränsa värden
Steg 2: Begränsa värden till ett giltigt intervall, till exempel 0–100. Ogiltiga negativa värden blir 0 och för stora värden blir 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);
}
}
Normalisera formen
Steg 3: Normalisera till en rektangulär form genom att fylla ut varje kort (eller null) rad till längden på den längsta raden med ett utfyllnadsvärde, till exempel 0.
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);
}
}
Valideringsrapport
Steg 4: Skapa en valideringsrapport: räkna negativa värden, för stora värden, null-rader och det totala antalet besökta celler.
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);
}
}
Utskrift som hoppar över null
Steg 5: Tillhandahåll kolumnjusterad utskrift som på ett robust sätt hoppar över null-rader och respekterar varje rads längd.
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);
}
}
Kontroll av säker åtkomst
Snabb kontroll: Hur får man säkert åtkomst till m[r][c] i potentiellt ojämna data?
Repetition och nästa steg
Repetition: Ni kopierade data defensivt, kontrollerade index, begränsade värden, normaliserade ojämna former och skapade valideringssammanfattningar. Dessa byggstenar gör senare 2D-algoritmer robusta.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”Rensning och validering av 2D-data” gratis?
Ja – hela texten till ”Rensning och validering av 2D-data” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 6 lektioner.
Vad lär jag mig i ”Rensning och validering av 2D-data”?
Rensa och validera 2D-heltalsdata: hantera null-rader, kontrollera indexgränser, begränsa värden utanför intervallet, normalisera ojämna former och skapa valideringsrapporter. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 6 av 6.
Hur lång tid tar lektionen ”Rensning och validering av 2D-data”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Grunderna i 2D-arrayer och nästlad iteration
- Ojämna arrayer och tabellformatering
- Maxvärden per rad/kolumn, transponering och formatering
- 2D-miniprojekt: betygsbok
- 2D-verktyg som hjälparklass (refaktorering)
- Rensning och validering av 2D-data