@@ -146,6 +146,8 @@ for (int i = 0; i < zahlen.length; i++) {
 - Ein leeres Array mit 5 Fächern legst du mit `new int[5]` an.
 - `zahlen[i]` ist das Fach mit dem Index `i`, `zahlen.length` die Länge.
 
+Gibst du das ganze Array aus, also `System.out.println(zahlen);`, zeigt Java nicht die Zahlen. Du siehst nur einen Text wie `[I@1b6d3586`. Das ist die **Referenz**, also die Stelle, an der das Array im Speicher liegt. Den Inhalt zeigt erst `Arrays.toString(zahlen)`, das ergibt `[2, 4, 6, 8, 10]`. Dafür schreibst du ganz oben `import java.util.Arrays;`.
+
 ::: übung l15-java-noten
 titel: Notensumme in Java
 code: java
 
@@ -146,6 +146,8 @@ for (int i = 0; i < numbers.length; i++) {
 - You create an empty array with 5 slots with `new int[5]`.
 - `numbers[i]` is the slot with index `i`, `numbers.length` is the length.
 
+If you output the whole array, that is `System.out.println(numbers);`, Java does not show the numbers. You only see a text like `[I@1b6d3586`. This is the **reference**, the place where the array is stored in memory. `Arrays.toString(numbers)` shows the content: `[2, 4, 6, 8, 10]`. For this you write `import java.util.Arrays;` at the very top.
+
 ::: übung l15-java-noten
 titel: Sum of grades in Java
 code: java
 
@@ -146,6 +146,8 @@ for (int i = 0; i < numeros.length; i++) {
 - Um array vazio com 5 posições cria-se com `new int[5]`.
 - `numeros[i]` é a posição com o índice `i`, `numeros.length` é o comprimento.
 
+Se mostrares o array inteiro, ou seja `System.out.println(numeros);`, o Java não mostra os números. Só vês um texto como `[I@1b6d3586`. É a **referência**, o sítio onde o array está guardado na memória. O conteúdo só aparece com `Arrays.toString(numeros)`, que dá `[2, 4, 6, 8, 10]`. Para isso escreves `import java.util.Arrays;` logo no início.
+
 ::: übung l15-java-noten
 titel: Soma das notas em Java
 code: java
 
@@ -1085,27 +1085,31 @@ function documentContainsJavaInput(doc: VSDocument): boolean {
   return found
 }
 
+const arraysImport = 'import java.util.Arrays;'
+
 /**
  * Imports für Dateien: `Files`/`Path` aus `java.nio.file`, `File`, `PrintWriter`, `FileReader` und `BufferedReader` aus
- * `java.io`, dazu `java.util.Scanner` für einen Scanner auf einer Datei.
+ * `java.io`, dazu `java.util.Scanner` für einen Scanner auf einer Datei und `java.util.Arrays` für `Arrays.toString(…)`.
  */
 export function fileImports(doc: VSDocument): string[] {
   let nio = false
   let io = false
   let scanner = false
+  let arrays = false
   walkElements(doc.elements, (e) => {
     for (const l of e.textLines) {
+      if (/\bArrays\s*\./.test(l)) arrays = true
       if (/\bFiles\s*\./.test(l)) nio = true
       if (/\bnew\s+(?:File|PrintWriter|FileReader|FileWriter|BufferedReader)\s*\(/.test(l)) io = true
       if (/\bnew\s+Scanner\s*\(\s*new\s+File\b/.test(l)) scanner = true
     }
   })
-  return [...(io ? ['import java.io.*;'] : []), ...(nio ? ['import java.nio.file.*;'] : []), ...(scanner ? ['import java.util.Scanner;'] : [])]
+  return [...(io ? ['import java.io.*;'] : []), ...(nio ? ['import java.nio.file.*;'] : []), ...(scanner ? ['import java.util.Scanner;'] : []), ...(arrays ? [arraysImport] : [])]
 }
 
 /** Arbeitet das Programm mit Dateien? Dann kann eine IOException kommen, und Java verlangt `throws` an der Methode. */
 export function documentReadsFiles(doc: VSDocument): boolean {
-  return fileImports(doc).length > 0
+  return fileImports(doc).some((i) => i !== arraysImport)
 }
 
 function documentContainsJavaMathRandom(doc: VSDocument): boolean {
@@ -1794,7 +1798,7 @@ export function generateJavaClassFile(
   const scannerField = methods.length > 0 && (hasInput || methodInput)
   // `Files.readString` kann eine IOException werfen; Java verlangt dann `throws` an der Methode.
   const imports = [...new Set([document, ...methodDocs.map((m) => m.d)].flatMap(fileImports))]
-  const files = imports.length > 0
+  const files = imports.some((i) => i !== arraysImport)
   if ((hasInput || methodInput) && !imports.includes('import java.util.Scanner;')) imports.push('import java.util.Scanner;')
   for (const line of imports) out += line + '\n'
   if (imports.length) out += '\n'
 
@@ -223,14 +223,15 @@ class Parser {
 
   /**
    * Wie javac: `Scanner` ohne `import java.util.Scanner;` (oder `java.util.*`) ist ein Fehler, ebenso `Files` und `Path` ohne
-   * `java.nio.file` und `File`, `PrintWriter`, `FileReader`, `FileWriter`, `BufferedReader` ohne `java.io`.
+   * `java.nio.file`, `File`, `PrintWriter`, `FileReader`, `FileWriter`, `BufferedReader` ohne `java.io` und `Arrays` ohne
+   * `java.util.Arrays`.
    */
   checkImports() {
     const io = ['File', 'PrintWriter', 'FileReader', 'FileWriter', 'BufferedReader', 'IOException', 'FileNotFoundException'].map((n) => [n, 'java.io'])
-    for (const [name, pkg] of [['Scanner', 'java.util'], ['Files', 'java.nio.file'], ['Path', 'java.nio.file'], ['Paths', 'java.nio.file'], ...io]) {
+    for (const [name, pkg] of [['Scanner', 'java.util'], ['Arrays', 'java.util'], ['Files', 'java.nio.file'], ['Path', 'java.nio.file'], ['Paths', 'java.nio.file'], ...io]) {
       const known = this.imports.some((i) => i === `import${pkg}.${name};` || i === `import${pkg}.*;`)
       // `Files.readString(…)`: nur als Klasse vor einem Punkt, damit eine Variable `path` o. Ä. nicht zählt.
-      const use = this.toks.find((t, k) => t.kind === 'id' && t.text === name && (pkg !== 'java.nio.file' || this.toks[k + 1]?.text === '.'))
+      const use = this.toks.find((t, k) => t.kind === 'id' && t.text === name && (name !== 'Arrays' && pkg !== 'java.nio.file' || this.toks[k + 1]?.text === '.'))
       if (!known && use) {
         this.problem('web_parse_missing_import', use, pkg === 'java.util' ? `import ${pkg}.${name};` : `import ${pkg}.*;`)
         return
 
@@ -234,6 +234,38 @@ function elementDefault(type: SimValueType): number | string | boolean {
   return type === 'string' ? '' : type === 'boolean' ? false : 0
 }
 
+/**
+ * Was `System.out.println(zahlen)` in Java ausgibt: nicht den Inhalt, sondern Typ und Kennung der Referenz,
+ * z. B. `[I@1b6d3586`. Den Inhalt zeigt erst `Arrays.toString(zahlen)`. Die Kennung bleibt für dasselbe Array gleich.
+ */
+const arrayIds = new WeakMap<object, string>()
+let nextArrayId = 0
+
+export function javaReference(v: SimValue): string {
+  const code = (t: SimValueType) => ({ int: 'I', double: 'D', boolean: 'Z', string: 'Ljava.lang.String;' })[t]
+  const prefix =
+    v.kind === 'grid' ? '[[' + code(v.elementType)
+    : v.kind === 'intArray' ? '[I'
+    : v.kind === 'doubleArray' ? '[D'
+    : v.kind === 'booleanArray' ? '[Z'
+    : v.kind === 'stringArray' ? '[Ljava.lang.String;'
+    : undefined
+  if (!prefix || !('value' in v)) return describeValue(v)
+  const key = v.value as object
+  let id = arrayIds.get(key)
+  if (!id) {
+    id = ((Math.imul(++nextArrayId, 0x9e3779b1) >>> 0) & 0x7fffffff).toString(16)
+    arrayIds.set(key, id)
+  }
+  return prefix + '@' + id
+}
+
+/** Ein Fach wurde geändert und das Array dabei kopiert: Es ist in Java aber dasselbe Array, also dieselbe Kennung. */
+function keepArrayId(from: object, to: object): void {
+  const id = arrayIds.get(from)
+  if (id) arrayIds.set(to, id)
+}
+
 function isArrayValue(v: SimValue): boolean {
   return v.kind === 'intArray' || v.kind === 'doubleArray' || v.kind === 'stringArray' || v.kind === 'booleanArray' || v.kind === 'grid'
 }
@@ -1815,7 +1847,10 @@ export class SimulationEngine {
     }
   }
 
-  /** `Integer.parseInt(…)`, `Double.parseDouble(…)`, `String.valueOf(…)`, `Files.readString(Path.of(…))`. */
+  /**
+   * `Integer.parseInt(…)`, `Double.parseDouble(…)`, `String.valueOf(…)`, `Files.readString(Path.of(…))`,
+   * `Arrays.toString(…)` und `Arrays.deepToString(…)`.
+   */
   private evaluateStaticCall(text: string, call: { target: string; method: string; args: string[] }): SimValue | undefined {
     const one = () => {
       if (call.args.length !== 1) throw invalid(text)
@@ -1841,6 +1876,17 @@ export class SimulationEngine {
       }
       case 'String.valueOf':
         return { kind: 'string', value: this.evaluateOutputExpression(one()) }
+      case 'Arrays.toString':
+      case 'Arrays.deepToString': {
+        const array = this.state.variables.get(one().trim())
+        if (!array || !isArrayValue(array)) throw invalid(text)
+        // `Arrays.toString` zeigt bei einem 2D-Array nur die Referenzen der Zeilen, `deepToString` alles.
+        if (array.kind === 'grid' && call.method === 'toString') {
+          const rows = array.value.map((row) => javaReference({ kind: `${array.elementType}Array`, value: row } as SimValue))
+          return { kind: 'string', value: '[' + rows.join(', ') + ']' }
+        }
+        return { kind: 'string', value: describeValue(array) }
+      }
       case 'Files.readString': {
         const path = /^(?:Path\s*\.\s*of|Paths\s*\.\s*get)\s*\(\s*("(?:[^"\\]|\\.)*")\s*\)$/u.exec(one().trim())
         if (!path) throw invalid(text)
@@ -1953,6 +1999,7 @@ export class SimulationEngine {
       if (raw === undefined || isArrayValue(value)) throw invalid(trimmed)
       const rows = old.value.map((row) => [...row])
       rows[indices[0]][indices[1]] = raw as number | string | boolean
+      keepArrayId(old.value, rows)
       this.state.variables.set(access.arrayName, { ...old, value: rows })
       return
     }
@@ -1972,6 +2019,7 @@ export class SimulationEngine {
     }
     if (index >= (updated.value as unknown[]).length) throw invalid(trimmed)
     ;(updated.value as unknown[])[index] = value.value
+    keepArrayId(old.value, updated.value)
     this.state.variables.set(access.arrayName, updated)
   }
 
@@ -1992,7 +2040,8 @@ export class SimulationEngine {
         else sum = sum.kind === 'int' && value.kind === 'int' ? int(sum.value + value.value) : dbl((sum as { value: number }).value + (value as { value: number }).value)
         continue
       }
-      text = (text ?? (sum ? describeValue(sum) : '')) + describeValue(value)
+      // Ein ganzes Array gibt Java nur als Referenz aus, z. B. `[I@1b6d3586`.
+      text = (text ?? (sum ? describeValue(sum) : '')) + javaReference(value)
       sum = undefined
     }
     return text ?? (sum ? describeValue(sum) : '')
 
@@ -152,6 +152,13 @@ describe('Java tippen → Struktogramm', () => {
     expect(keys('System.out.println("Scanner");')).toEqual([])
   })
 
+  it('Arrays ohne import ist ein Fehler, wie bei javac', () => {
+    const keys = (src: string) => parse(src).problems.map((p) => p.key)
+    expect(keys('int[] a = {1, 2};\nSystem.out.println(Arrays.toString(a));')).toEqual(['web_parse_missing_import'])
+    expect(keys('import java.util.Arrays;\nint[] a = {1, 2};\nSystem.out.println(Arrays.toString(a));')).toEqual([])
+    expect(keys('int[] a = {1, 2};\nSystem.out.println(a);')).toEqual([])
+  })
+
   it('Aufruf eines Unterprogramms aus einem anderen Reiter', () => {
     expect(parse('int y = quadrat(4);', new Set(['quadrat'])).elements[0].type).toBe(ElementType.aufruf)
     expect(parse('int y = quadrat(4);').elements[0].type).toBe(ElementType.anweisung)
 
@@ -173,14 +173,42 @@ describe('Simulation', () => {
     expect(engine.message).toBe('Simulation finished.')
   })
 
+  it('gibt ein ganzes Array wie Java als Referenz aus, den Inhalt erst mit Arrays.toString', () => {
+    const state = runSimulation(
+      doc([
+        stmt('int[] zahlenreihe = {1, 2, 3}'),
+        stmt('String[] namen = {"Ada", "Bob"}'),
+        stmt('double[][] t = new double[2][2]'),
+        stmt('output: zahlenreihe'),
+        stmt('zahlenreihe[0] = 9'),
+        stmt('output: "Reihe: " + zahlenreihe'),
+        stmt('output: namen'),
+        stmt('output: t'),
+        stmt('output: Arrays.toString(zahlenreihe)'),
+        stmt('output: Arrays.toString(namen)'),
+        stmt('output: Arrays.deepToString(t)'),
+        stmt('output: Arrays.toString(t)'),
+      ]),
+    )
+    const [ref, refAgain, names, grid, ...rest] = state.outputLines
+    expect(ref).toMatch(/^\[I@[0-9a-f]+$/u)
+    expect(refAgain).toBe('Reihe: ' + ref)
+    expect(names).toMatch(/^\[Ljava\.lang\.String;@[0-9a-f]+$/u)
+    expect(grid).toMatch(/^\[\[D@[0-9a-f]+$/u)
+    expect(rest.slice(0, 3)).toEqual(['[9, 2, 3]', '[Ada, Bob]', '[[0.0, 0.0], [0.0, 0.0]]'])
+    expect(rest[3]).toMatch(/^\[\[D@[0-9a-f]+, \[D@[0-9a-f]+\]$/u)
+    // Die Variablentabelle zeigt weiter den Inhalt.
+    expect(state.variables.get('zahlenreihe')).toEqual({ kind: 'intArray', value: [9, 2, 3] })
+  })
+
   it('Werte und Arrays', () => {
     const state = runSimulation(
       doc([
         stmt('double d = 7.0 / 2'),
         stmt('int[] a = {3, 4, 5}'),
         stmt('a[1] = a[0] * 10'),
         stmt('String s = "x"'),
-        stmt('print: "len=" + a.length + " a=" + a + " d=" + d'),
+        stmt('print: "len=" + a.length + " a=" + Arrays.toString(a) + " d=" + d'),
         stmt('d += 1'),
       ]),
     )