Java Academy · Lección

Limpieza y validación de datos 2D

Limpie y valide datos enteros 2D: controle las filas nulas, compruebe los índices, limite los valores fuera de rango, normalice las formas irregulares y genere informes de validación.

Limpieza y validación de datos 2D es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 6 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 6 lecciones en total.

Por qué limpiar los datos bidimensionales

Objetivo: Hacer que los datos enteros bidimensionales sean seguros y coherentes. Vamos a: (1) controlar las filas nulas, (2) comprobar los límites de cada fila, (3) limitar los valores a un rango válido, (4) normalizar las formas irregulares cuando sea necesario y (5) generar un informe de validación.

Nulos y límites

Paso 1: Reemplace las filas nulas por arreglos vacíos y copie los valores de forma defensiva. Proporcione un auxiliar inBounds para comprobar los límites según la longitud de cada fila.

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
  }
}

Limitar valores

Paso 2: Limite los valores a un rango válido (por ejemplo, 0–100). Los negativos no válidos se convierten en 0 y los valores demasiado grandes se convierten en 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);
  }
}

Normalizar la forma

Paso 3: Normalice la matriz a una forma rectangular rellenando cada fila corta (o nula) hasta alcanzar la longitud de la fila más larga, mediante un valor de relleno (por ejemplo, 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);
  }
}

Informe de validación

Paso 4: Cree un informe de validación: cuente los valores negativos, los valores demasiado grandes, las filas nulas y el total de celdas visitadas.

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);
  }
}

Impresión omitiendo nulos

Paso 5: Proporcione una impresión alineada que omita correctamente las filas nulas y respete la longitud de cada fila.

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);
  }
}

Comprobación de acceso seguro

Comprobación rápida: ¿Cómo se accede de forma segura a m[r][c] en datos potencialmente irregulares?

Repaso y siguiente paso

Repaso: Copió los datos de forma defensiva, controló los índices, limitó los valores, normalizó las formas irregulares y generó resúmenes de validación. Estos componentes básicos hacen que los algoritmos bidimensionales posteriores sean robustos.

Preguntas frecuentes

¿La lección «Limpieza y validación de datos 2D» es gratis?

Sí — el texto completo de «Limpieza y validación de datos 2D» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 6 lecciones en total.

¿Qué aprenderé en «Limpieza y validación de datos 2D»?

Limpie y valide datos enteros 2D: controle las filas nulas, compruebe los índices, limite los valores fuera de rango, normalice las formas irregulares y genere informes de validación. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 6 de 6.

¿Cuánto tiempo toma la lección «Limpieza y validación de datos 2D»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy