Nettoyage et validation des données 2D
Nettoyez et validez des données entières 2D : gérez les lignes nulles, vérifiez les index, bornez les valeurs hors limites, normalisez les formes irrégulières et produisez des rapports de validation.
Nettoyage et validation des données 2D est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 6 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 6 leçons au total.
Pourquoi nettoyer les données à deux dimensions ?
Objectif : Rendre les données entières à deux dimensions sûres et cohérentes. Nous allons : (1) gérer les lignes nulles, (2) vérifier les limites pour chaque ligne, (3) borner les valeurs dans un intervalle valide, (4) normaliser les formes irrégulières lorsque nécessaire et (5) produire un rapport de validation.
Valeurs nulles et limites
Étape 1 : Remplacez les lignes nulles par des tableaux vides et copiez les valeurs de manière défensive. Fournissez un utilitaire inBounds pour vérifier la longueur de chaque ligne.
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
}
}
Limiter les valeurs
Étape 2 : Bornez les valeurs dans un intervalle valide (par exemple, 0–100). Les valeurs négatives invalides deviennent 0 et les valeurs trop élevées deviennent 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);
}
}
Normaliser la forme
Étape 3 : Normalisez les données sous une forme rectangulaire en complétant chaque ligne courte (ou nulle) jusqu’à la longueur de la ligne la plus longue, à l’aide d’une valeur de remplissage (par exemple, 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);
}
}
Rapport de validation
Étape 4 : Établissez un rapport de validation : comptez les valeurs négatives, les valeurs trop élevées, les lignes nulles et le total des cellules parcourues.
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);
}
}
Affichage en ignorant les lignes nulles
Étape 5 : Fournissez un affichage aligné qui ignore proprement les lignes nulles et respecte la longueur de chaque ligne.
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);
}
}
Vérification de l’accès sécurisé
Vérification rapide : Comment accéder en toute sécurité à m[r][c] avec des données potentiellement irrégulières ?
Récapitulatif et suite
Récapitulatif : Vous avez copié les données de manière défensive, vérifié les indices, borné les valeurs, normalisé les formes irrégulières et produit des synthèses de validation. Ces éléments de base rendent fiables les algorithmes à deux dimensions des leçons suivantes.
Questions Fréquemment Posées
La leçon « Nettoyage et validation des données 2D » est-elle gratuite ?
Oui — le texte complet de « Nettoyage et validation des données 2D » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 6 leçons au total.
Qu'est-ce que j'apprendrai dans « Nettoyage et validation des données 2D » ?
Nettoyez et validez des données entières 2D : gérez les lignes nulles, vérifiez les index, bornez les valeurs hors limites, normalisez les formes irrégulières et produisez des rapports de validation. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 6 sur 6.
Combien de temps prend la leçon « Nettoyage et validation des données 2D » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Bases des tableaux 2D et parcours imbriqué
- Tableaux irréguliers et mise en forme des tableaux
- Maximums par ligne/colonne, transposition et mise en forme
- Mini-projet 2D : carnet de notes
- Utilitaires 2D dans une classe d’aide (refactorisation)
- Nettoyage et validation des données 2D