diff --git a/Array.java b/Array.java
new file mode 100644
index 0000000..2b7d131
--- /dev/null
+++ b/Array.java
@@ -0,0 +1,28 @@
+
+/**
+ * Beschreiben Sie hier die Klasse Array.
+ * 
+ * @author (Ihr Name) 
+ * @version (eine Versionsnummer oder ein Datum)
+ */
+public class Array
+{
+    public static void test()
+    {
+        int[] array = new int[10];
+        array[1]= 3;
+        array[2]= 25;
+        array[3]= 40;
+        array[4]= 50;
+        array[6]= 1000;
+        array[7]= 2000;
+        array[8]= 2200;
+        array[9]= 2222;
+        System.out.println(array[1]);
+        for(int i= 0;i< array.length;i++)
+        {
+            System.out.println(array[i]);
+        }
+    }
+    
+}
diff --git a/ArrayExperimente.java b/ArrayExperimente.java
new file mode 100644
index 0000000..54f8523
--- /dev/null
+++ b/ArrayExperimente.java
@@ -0,0 +1,176 @@
+
+/**
+ * Uebungen mit Arrays. 
+ * 
+ * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchfuehren.
+ * 
+ * Du kannst deine Loesungen mit der beigefuegten Testklasse automatisch 
+ * ueberpruefen
+ *   - Klicke dazu im Hauptfenster auf Werkzeuge -> Testen -> Tests  starten
+ *   - Sobald du glaubst, eine Funktion fertig programmiert zu haben, 
+ *     startest du die Tests und ueberzeugst dich im Testergebnisfenster, 
+ *     dass der Test fuer diese Funktion erfolgreich durchgelaufen ist.
+ *   - Falls er fehlschlaegt, kannst du dort auf den entsprechenden Test klicken
+ *     und nachschauen, was genau fehlgeschlagen ist.
+ *     
+ */
+public class ArrayExperimente
+{
+    public static int beispiel[]= new int[] {1, 3, 4, -13, 0, 70, -111};
+    public static int nochnArray[]= new int[] {20,21,22,23,24,25,26};
+
+    /**
+     * Gibt das uebergebene Array auf der Konsole aus.
+     * @param array, das ausgegeben werden soll.
+     */
+    public static void arrayAusgeben(int[] array)
+    {
+        for(int i=0; i<array.length; i++)
+        {
+            System.out.println(array[i]);
+        }
+    }
+
+    /**
+     * Ermittelt, ob ein Wert im Array vorkommt, d.h. ob
+     * eines der Arrayelemente diesen Wert hat.
+     * @param gesucht zu suchender Wert.
+     * @param array Array, in dem gesucht wird.
+     * @returns ob gesucht im Array vorkommt.
+     */    
+    public static boolean istEnthalten(int gesucht, int[] array)
+    {
+        for(int i=0; i<array.length; i++)
+        {
+            if(array[i] == gesucht)
+            {
+                return true;
+            }
+            
+            
+        }
+        return false;
+    }    
+
+    /**
+     * Ermittelt, an welchem Index im Array der Wert "gesucht" vorkommt.
+     * @param gesucht Wert, nach dem im Array gesucht wird.
+     * @param array Array, in dem gesucht wird.
+     * @returns den Index, an dem gesucht im Array vorkommt; -1, falls es
+     * nicht vorkommt.
+     */
+    public static int indexVon(int gesucht, int[] array)
+    {
+        // TODO...
+
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return -3245646;
+    }    
+
+
+
+    /**
+     * Ermittelt den Wert des groessten im Array enthaltenen Elements.
+     * @param array Array, in dem gesucht wird. Es darf 
+     * nicht leer sein.
+     * @returns Den groessten vorkommenden Wert.
+     */
+    public static int maxWert(int[] array)
+    {
+        // TODO...
+
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return -346;
+    }
+
+    /**
+     * Ermittelt den Index des groessten im Array enthaltenen Elements.
+     * @param array Array, in dem gesucht wird.
+     * @returns Den Index des groessten vorkommenden Werts.
+     */
+    public static int maxIndex(int[] array)
+    {
+        // TODO...
+
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return -324688;
+
+    }
+
+    /**
+     * Ermittelt den Index des groessten im Array enthaltenen Elements. 
+     * @param array Array, in dem gesucht wird.
+     * @returns Den Index des groessten vorkommenden Werts.
+     */
+    public static int maxIndexKuerzer(int[] aray)
+    {
+        // TODO: Formuliere diese Funktion als Einzeiler, indem du
+        // Funktionen, die du oben schon geschrieben hast, geschickt aufrufst.
+        // Diese Variante einfacher zu formulieren als mit einer Schleife
+        // (braucht allerdings mehr Rechenschritte).
+
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return -3244786;
+    }
+
+    /**
+     * Ermittelt die Summe ueber alle Arrayelemente.
+     * @param array Array, das aufaddiert wird.
+     * @returns Summe aller Arrayelemente.
+     */
+    public static int querSumme(int[] array)
+    {
+        // TODO...
+
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return -32460;
+    }    
+
+    /**
+     * Die Funktion erhoeht im urspruenglichen Array jeden Eintrag um "zuschlag".
+     * Es wird kein neues Array angelegt.
+     * @param array Zu manipulierendes Array. Es darf nicht leer sein.    
+     * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazuaddiert.
+     */
+    public static void addiereJeweilsD(int[] array, int zuschlag)
+    {
+        // TODO...
+    }
+
+    
+
+    /**
+     * Erstellt ein neues Array, in dem die Elemente des
+     * urspruenglichen Array in der umgekehrten Reihenfolge drin sind.
+     * @param array urspruengliches Array, darf nicht null sein
+     * @returns neues Array mit umgekehrter Reihenfolge.
+     */
+    public static int[] arrayUmdrehen(int[] array)
+    {
+        // fuer diese Funktion darf man ein neues Array anlegen, das 
+        // die Eintraege von wendeArray in umgedrehter Reihenfolge enthaelt.
+        
+        // TODO...
+        
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return null;
+
+        
+    }
+
+    /**
+     * Dreht im bestehenden Array dessen Elemente in 
+     * die umgekehrte Reihenfolge. Man sagt, die Funktion bearbeitet 
+     * das Array "in place".
+     * @param wendeArray urspruengliches Array 
+     */
+    public static void arrayUmdrehenInPlace(int[] array)
+    {
+        // Diese Funktion loest die gleiche Aufgabe wie die obere, darf
+        // dafuer aber KEIN zusaetzliches Array benutzen, sondern muss 
+        // (bis auf einzelne int-Variable) im wendeArray arbeiten.
+        // TODO...
+    }
+
+   
+}
diff --git a/ArrayExperimenteTest.java b/ArrayExperimenteTest.java
new file mode 100644
index 0000000..9e39250
--- /dev/null
+++ b/ArrayExperimenteTest.java
@@ -0,0 +1,205 @@
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import java.util.Arrays;
+
+/**
+ * The test class ArrayExperimenteTest.
+ *
+ * @author  Urs Lautebach
+ * @version 2017-10
+ */
+public class ArrayExperimenteTest
+{
+    /**
+     * Sets up the test fixture.
+     *
+     * Called before every test case method.
+     */
+    @Before
+    public void setUp()
+    {
+    }
+
+    /**
+     * Tears down the test fixture.
+     *
+     * Called after every test case method.
+     */
+    @After
+    public void tearDown()
+    {
+    }
+
+    @Test
+    public void testistEnthalten()
+    {
+        int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
+        assertTrue(ArrayExperimente.istEnthalten(1000, testArray));
+        assertTrue(ArrayExperimente.istEnthalten(-41, testArray));
+        assertTrue(ArrayExperimente.istEnthalten(1, testArray));
+        assertFalse(ArrayExperimente.istEnthalten(77, testArray));
+
+        testArray = new int[] {66};
+        assertTrue(ArrayExperimente.istEnthalten(66, testArray));
+        assertFalse(ArrayExperimente.istEnthalten(77, testArray));
+
+        testArray = new int[] {};
+        assertFalse(ArrayExperimente.istEnthalten(77, testArray));
+    }
+
+    @Test
+    public void testindexVon()
+    {
+        int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
+        assertEquals(0, ArrayExperimente.indexVon(1, testArray));
+        assertEquals(1, ArrayExperimente.indexVon(-43, testArray));
+        assertEquals(9, ArrayExperimente.indexVon(-41, testArray));
+        assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
+
+        testArray = new int[] {66};
+        assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
+        assertEquals(0, ArrayExperimente.indexVon(66, testArray));
+
+        testArray = new int[] {};
+        assertEquals(-1, ArrayExperimente.indexVon(1231, testArray));
+    }
+
+
+
+    @Test
+    public void testmaxWert()
+    {
+        int[] testArray = new int[] {1, -43, 1000, 1000, 3, 4, 13, 1000, 70, -41};
+        assertEquals(1000, ArrayExperimente.maxWert(testArray));
+
+        testArray = new int[] {0, -43, -41};
+        assertEquals(0, ArrayExperimente.maxWert(testArray));
+
+        testArray = new int[] {-43, -41};
+        assertEquals(-41, ArrayExperimente.maxWert(testArray));
+
+        testArray = new int[] {66};
+        assertEquals(66, ArrayExperimente.maxWert(testArray));
+    }
+
+    @Test
+    public void testmaxIndex()
+    {
+        int[] testArray = new int[] {1, -43, 1000, 3, 4, 13, 70, -41};
+        assertEquals(2, ArrayExperimente.maxIndex(testArray));
+
+        testArray = new int[] {1, -43, 1000, 3, 4, 13, 70, -41, 5367};
+        assertEquals(8, ArrayExperimente.maxIndex(testArray));
+
+        testArray = new int[] {0, -43, -41};
+        assertEquals(0, ArrayExperimente.maxIndex(testArray));
+
+        testArray = new int[] {-43, -41};
+        assertEquals(1, ArrayExperimente.maxIndex(testArray));
+
+        testArray = new int[] {-41};
+        assertEquals(0, ArrayExperimente.maxIndex(testArray));
+    }
+
+    @Test
+    public void testquersumme()
+    {
+        int[] testArray = new int[] {1, -43, 3, 4, 13, 70, -41};
+        assertEquals(7, ArrayExperimente.querSumme(testArray));
+
+        testArray = new int[] {0, -43, -41};
+        assertEquals(-84, ArrayExperimente.querSumme(testArray));
+
+        // einelementiges Array:
+        testArray = new int[] {51};
+        assertEquals(51, ArrayExperimente.querSumme(testArray));
+    }
+
+    @Test
+    public void testaddiereJeweilsD()
+    {
+        int[] arrayVorher = new int[] {1, -43, 3, 4, 13, 70, -41};
+        int[] testArray   = new int[] {1, -43, 3, 4, 13, 70, -41};
+
+        int dazu = 1;
+        ArrayExperimente.addiereJeweilsD(testArray, dazu);
+
+        int idx = 0;
+        while(idx < testArray.length)
+        {
+            if( testArray[idx] != arrayVorher[idx] + dazu )
+            {
+                fail("Arrays unterscheiden sich an der Position " + idx + "!");
+            }
+            idx ++ ;
+        }
+    }
+
+
+
+    @Test
+    public void testarrayUmdrehen()
+    {
+        // Array mit ungerader Laenge:
+        int[] drehmich = new int[] { 1, -43, 3, 4, 13, 70, -41 };
+        int[] rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
+        assertEquals(drehmich.length, rumgedreht.length);
+
+        int idx = 0;
+        while(idx < drehmich.length) {
+            if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
+                fail("Ergebnisarray falsch bei Index " + idx + "!");
+            }
+            idx ++ ;
+        }
+
+        // Array mit gerader Laenge:
+        drehmich = new int[] { 1, -43, 3, 4, 70, -41 };
+        rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
+        assertEquals(drehmich.length, rumgedreht.length);
+
+        idx = 0;
+        while(idx < drehmich.length) {
+            if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
+                fail("Ergebnisarray falsch bei Index " + idx + "!");
+            }
+            idx ++ ;
+        }
+
+        // Array mit Laenge 1:
+        drehmich = new int[] { 1 };
+        rumgedreht = ArrayExperimente.arrayUmdrehen(drehmich);
+        assertEquals(drehmich.length, rumgedreht.length);
+
+        idx = 0;
+        while(idx < drehmich.length) {
+            if( rumgedreht[idx] != drehmich[ rumgedreht.length - 1 - idx ] ) {
+                fail("Ergebnisarray falsch bei Index " + idx + "!");
+            }
+            idx ++ ;
+        }
+    }
+
+   
+
+    private boolean[][] binaer =  
+        {
+            { false, false, false, false, false, false, false, false } , /*    0      */ 
+            { false, true , true , true , true , true , true , true  } , /*    127    */ 
+            { false, false, false, false, false, true , true , true  } , /*    7      */ 
+            { false, true , true , false, false, false, false, false } , /*    96     */ 
+            { false, false, true , false, false, true , false, false } , /*    36     */ 
+            { false, false, false, false, false, true , false, true  } , /*    5     */ 
+            { false, false, false, false, false, true , false, false } , /*    4     */ 
+            { false, false, false, true , false, false, false, true  } , /*    17     */ 
+            { false, true , false, false, false, false, false, true  } , /*    65     */ 
+            { false, false, false, false, false, false, false, true  } , /*    1     */ 
+
+        };
+
+    private byte[] dezimal = { 0, 127, 7, 96, 36, 5, 4, 17, 65, 1};
+
+    
+}