Wie kann ich dieses Java-Array lesen (also verstehen)?

Question

String[][][] arr = 
{{ { "a", "b" , "c"}, { "d", "e", null } },{ {"x"}, null },{{"y"}},{ { "z","p"}, {} }}; 

Ich habe Grund zu der Annahme, dass so etwas irgendwann auf eine Prüfung kommen wird, aber in +10 Jahren Codierung habe ich noch nie einen solchen Horror gesehen. Ich könnte sicher einige Tipps für die mentale Analyse verwenden, damit ich herausfinden kann, was es wirklich in meinem Kopf bedeutet. Klar, ich könnte es durch IntelliJ laufen lassen, aber ich werde es nicht verfügbar haben.

Für das Protokoll, macht dies durchaus Sinn für mich:

int[][] twoD = { { 1, 2, 3} , { 4, 5, 6, 7}, { 8, 9, 10 } }; 

Answer 1

Ich empfehle eine Vertiefung hinzugefügt, die Sie im Auge zu behalten, helfen, was auf welcher Ebene dieses verschachtelten Array:

String[][][] arr = { 
    { 
     { "a", "b", "c" }, 
     { "d", "e", null } 
    }, 
    { 
     { "x" }, 
     null 
    }, 
    { 
     { "y" } 
    }, 
    { 
     { "z", "p" }, 
     {} 
    } 
}; 

Hilft das? Ich finde das macht es einfacher, die Datenstruktur zu visualisieren und Fragen wie "Was ist der Wert von arr[1][0][0]?" Zu beantworten.

Sie können den Typ String[][][] als "ein Array von Arrays von Arrays von Strings" oder vielleicht "ein dreidimensionales Array von Strings" lesen.

Answer 2

die Array Formatieren helfen, um herauszufinden, dass als eine Matrix von Zeilen und cols

String[][][] arr = 
{ 
    {{"a", "b" , "c"}, {"d", "e", null} }, 
    {{"x"   }, null    }, 
    {{"y"   }     }, 
    {{"z", "p"  }, {    }} 
}; 

2 Cols, 4 Reihen

Element bei 0,0: {"a", "b" , "c"}

Element bei 0,1: {"d", "e", null}

element bei 1,0: {"x"}

Element bei 1,1: null

etc etc

Answer 3

Vielleicht werden Sie mehr von diesem verstehen, ich Ihr Array wie folgt sehen:

String[] arr0 = {"a", "b", "c"}; 
String[] arr1 = {"d", "e", null}; 
String[] arr2 = {"x"}; 
String[] arr3 = null; 
String[] arr4 = {"y"}; 
String[] arr5 = {"z", "p"}; 
String[] arr6 = {}; 

String[][] arr0_1 = {arr0, arr1};//-->> {{"a", "b", "c"}, {"d", "e", null}} 
String[][] arr2_3 = {arr2, arr3};//-->> {{"x"}, null} 
String[][] arr4_4 = {arr4};  //-->> {{"y"}} 
String[][] arr5_6 = {arr5, arr6};//-->> {{"z", "p"}, {}} 

String[][][] arr = {arr0_1, arr2_3, arr4_4, arr5_6}; 

, die äquivalent ist

String[][][] arr 
     = { 
      {//---------------------------- 
       {"a", "b", "c"},//arr0 | 
             //|---->arr0_1 
       {"d", "e", null}//arr1 | 
      },//--------------------------- 

      {//---------------------------- 
       {"x"},//arr2    | 
             //|---->arr2_3 
       null //arr3    | 
      },//--------------------------- 

      {//---------------------------- 
       {"y"}//arr4    |---->arr4_4 
      },//--------------------------- 

      {//---------------------------- 
       {"z", "p"},//arr5   | 
             //|---->arr5_6 
       {}//arr6     | 
      }//--------------------------- 
     }; 

Answer 4

String[][][] arr = { 

      // arr[0] 
      { 
        /* arr[0][0] */ 
        { 
          /* arr[0][0][0] */ "a", 
          /* arr[0][0][1] */ "b", 
          /* arr[0][0][2] */ "c" 
        }, 

        /* arr[0][1] */ 
        { 
          /* arr[0][1][0] */ "d", 
          /* arr[0][1][1] */ "e", 
          /* arr[0][1][2] */ null 
        } 
      }, 

      // arr[1] 
      { 
        /* arr[1][0] */ 
        { 
          /* arr[1][0][0] */ "x" 
        }, 

        /* arr[1][1] */ 
        null 
      }, 

      // arr[2] 
      { 
        /* arr[2][0] */ 
        { 
          /* arr[2][0][0] */ "y" 
        } 
      }, 

      // arr[3] 
      { 
        /* arr[3][0] */ 
        { 
          /* arr[3][0][0] */ "z", 
          /* arr[3][0][1] */ "p" 
        }, 

        /* arr[3][1] */ 
        {} 
      } 
    }; 

Answer 5

Aufbauend auf @smarx Antwort:

// [][][] is an array of 2D arrays 
String[][][] arr = { // begin declaration of arr 
    // first 2D array 
    { 
     {"[0][0][0]", "[0][0][1]", "[0][0][2]"}, 
     {"[0][1][0]", "[0][1][1]", null, "[0][1][3]"} 
    }, 
    // second 2D array 
    { 
     {"[1][0][0]", "[1][0][1]"}, 
     null // we should check for this when reading 
    }, 
    // third 2D array 
    { 
     {"[2][0][0]", "[2][0][1]", "[2][0][2]"} 
    }, 
    // fourth 2D array 
    { 
     {"[3][0][0]", "[3][0][1]"}, 
     {} 
    }, 
    // fifth 2D array 
    { 
     {"[4][0][0]", "[4][0][1]", "[4][0][2]"}, 
     {"[4][1][0]", "[4][1][1]"}, 
     {"[4][2][0]", "[4][2][1]", "[4][2][2]"} 
    } 
}; 

// Reading the 3D array, as: [x][y][z] 
for (int x = 0; x < arr.length; x++) { 
    for (int y = 0; y < arr[x].length; y++) { 
     // one of our 2D arrays has a null array, 
     // declared in the line: {"[0][1][0]", "[0][1][1]", null, "[0][1][3]"} 
     if (arr[x][y] != null) { 
      for (int z = 0; z < arr[x][y].length; z++) { 
       System.out.println(arr[x][y][z]); 
      } 
     } else { 
      System.out.println("null 2D array"); 
     } 
    } 
} 

Wir für die Null-Arrays überprüfen müssen, weil wir etwas zuzugreifen versuchen, und es existiert nicht. Die Nullzeichenfolge muss nicht überprüft werden (zum Drucken), da Java diese Überprüfung bereits beim Drucken vornimmt, siehe why null reference prints as "null"?