diff --git a/user/super/com/google/gwt/emul/java/lang/reflect/Array.java b/user/super/com/google/gwt/emul/java/lang/reflect/Array.java
new file mode 100644
index 0000000..f9a3a6c
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/lang/reflect/Array.java
@@ -0,0 +1,264 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package java.lang.reflect;
+
+import static javaemul.internal.InternalPreconditions.checkArgument;
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+
+import javaemul.internal.ArrayHelper;
+
+/**
+ * See <a
+ * href="http://java.sun.com/javase/6/docs/api/java/lang/reflect/Array.html">the
+ * official Java API doc</a> for details.
+ */
+public final class Array {
+
+  public static Object get(Object array, int index) {
+    if (array instanceof boolean[]) {
+      return getBooleanImpl(array, index);
+    } else if (array instanceof byte[]) {
+      return getByteImpl(array, index);
+    } else if (array instanceof char[]) {
+      return getCharImpl(array, index);
+    } else if (array instanceof double[]) {
+      return getDoubleImpl(array, index);
+    } else if (array instanceof float[]) {
+      return getFloatImpl(array, index);
+    } else if (array instanceof int[]) {
+      return getIntImpl(array, index);
+    } else if (array instanceof long[]) {
+      return getLongImpl(array, index);
+    } else if (array instanceof short[]) {
+      return getShortImpl(array, index);
+    } else  {
+      checkArgument(array instanceof Object[]);
+      Object[] typedArray = (Object[]) array;
+      return typedArray[index];
+    }
+  }
+
+  public static boolean getBoolean(Object array, int index) {
+    checkArgument(array instanceof boolean[]);
+    return getBooleanImpl(array, index);
+  }
+
+  private static boolean getBooleanImpl(Object array, int index) {
+    boolean[] typedArray = (boolean[]) array;
+    return typedArray[index];
+  }
+
+  public static byte getByte(Object array, int index) {
+    checkArgument(array instanceof byte[]);
+    return getByteImpl(array, index);
+  }
+
+  private static byte getByteImpl(Object array, int index) {
+    byte[] typedArray = (byte[]) array;
+    return typedArray[index];
+  }
+
+  public static char getChar(Object array, int index) {
+    checkArgument(array instanceof char[]);
+    return getCharImpl(array, index);
+  }
+
+  private static char getCharImpl(Object array, int index) {
+    char[] typedArray = (char[]) array;
+    return typedArray[index];
+  }
+
+  public static double getDouble(Object array, int index) {
+    checkArgument(array instanceof double[]);
+    return getDoubleImpl(array, index);
+  }
+
+  private static double getDoubleImpl(Object array, int index) {
+    double[] typedArray = (double[]) array;
+    return typedArray[index];
+  }
+
+  public static float getFloat(Object array, int index) {
+    checkArgument(array instanceof float[]);
+    return getFloatImpl(array, index);
+  }
+
+  private static float getFloatImpl(Object array, int index) {
+    float[] typedArray = (float[]) array;
+    return typedArray[index];
+  }
+
+  public static int getInt(Object array, int index) {
+    checkArgument(array instanceof int[]);
+    return getIntImpl(array, index);
+  }
+
+  private static int getIntImpl(Object array, int index) {
+    int[] typedArray = (int[]) array;
+    return typedArray[index];
+  }
+
+  public static int getLength(Object array) {
+    checkNotNull(array);
+    return ArrayHelper.getLength(array);
+  }
+
+  public static long getLong(Object array, int index) {
+    checkArgument(array instanceof long[]);
+    return getLongImpl(array, index);
+  }
+
+  private static long getLongImpl(Object array, int index) {
+    long[] typedArray = (long[]) array;
+    return typedArray[index];
+  }
+
+  public static short getShort(Object array, int index) {
+    checkArgument(array instanceof short[]);
+    return getShortImpl(array, index);
+  }
+
+  private static short getShortImpl(Object array, int index) {
+    short[] typedArray = (short[]) array;
+    return typedArray[index];
+  }
+
+  public static void set(Object array, int index, Object value) {
+    if (array instanceof boolean[]) {
+      setBooleanImpl(array, index, (Boolean) value);
+    } else if (array instanceof byte[]) {
+      setByteImpl(array, index, (Byte) value);
+    } else if (array instanceof char[]) {
+      setCharImpl(array, index, (Character) value);
+    } else if (array instanceof double[]) {
+      setDoubleImpl(array, index, (Double) value);
+    } else if (array instanceof float[]) {
+      setFloatImpl(array, index, (Float) value);
+    } else if (array instanceof int[]) {
+      setIntImpl(array, index, (Integer) value);
+    } else if (array instanceof long[]) {
+      setLongImpl(array, index, (Long) value);
+    } else if (array instanceof short[]) {
+      setShortImpl(array, index, (Short) value);
+    } else {
+      checkArgument(array instanceof Object[]);
+      Object[] typedArray = (Object[]) array;
+      typedArray[index] = value;
+    }
+  }
+
+  public static void setBoolean(Object array, int index, boolean value) {
+    checkArgument(array instanceof boolean[]);
+    setBooleanImpl(array, index, value);
+  }
+
+  private static void setBooleanImpl(Object array, int index, boolean value) {
+    boolean[] typedArray = (boolean[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setByte(Object array, int index, byte value) {
+    checkArgument(array instanceof byte[]);
+    setByteImpl(array, index, value);
+  }
+
+  private static void setByteImpl(Object array, int index, byte value) {
+    byte[] typedArray = (byte[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setChar(Object array, int index, char value) {
+    checkArgument(array instanceof char[]);
+    setCharImpl(array, index, value);
+  }
+
+  private static void setCharImpl(Object array, int index, char value) {
+    char[] typedArray = (char[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setDouble(Object array, int index, double value) {
+    checkArgument(array instanceof double[]);
+    setDoubleImpl(array, index, value);
+  }
+
+  private static void setDoubleImpl(Object array,int index, double value) {
+    double[] typedArray = (double[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setFloat(Object array, int index, float value) {
+    checkArgument(array instanceof float[]);
+    setFloatImpl(array, index, value);
+  }
+
+  private static void setFloatImpl(Object array, int index, float value) {
+    float[] typedArray = (float[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setInt(Object array, int index, int value) {
+    checkArgument(array instanceof int[]);
+    setIntImpl(array, index, value);
+  }
+
+  private static void setIntImpl(Object array, int index, int value) {
+    int[] typedArray = (int[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setLong(Object array, int index, long value) {
+    checkArgument(array instanceof long[]);
+    setLongImpl(array, index, value);
+  }
+
+  private static void setLongImpl(Object array, int index, long value) {
+    long[] typedArray = (long[]) array;
+    typedArray[index] = value;
+  }
+
+  public static void setShort(Object array, int index, short value) {
+    checkArgument(array instanceof short[]);
+    setShortImpl(array, index, value);
+  }
+
+  private static void setShortImpl(Object array, int index, short value) {
+    short[] typedArray = (short[]) array;
+    typedArray[index] = value;
+  }
+
+  // There is a good reason to not implement the generic newInstance methods:
+  //
+  // In GWT we would need access from a class literal to the castable type map, which
+  // could be done, but would require some serious work.
+  // But it would also mean that we can not compute all Array types being instantiated anymore and
+  // thus would have to retain more castable type information (bloat).
+  //
+  // In J2CL the problem is slightly different. Most checking is deferred to runtime in J2CL and
+  // we retain constructor functions of leaf types. To ensure that we are not just retaining
+  // all constructors in a program we make sure that access to these always gets inlined with
+  // array creation. By allowing a generic method we would not be able to ensure this anymore
+  // and might cause serious bloat in a program.
+  // A middle ground for J2CL could be to treat this method special in the compiler and fail the
+  // compile if its not called with a compile time constant for the class literal.
+
+  // Not implemented:
+  // public static Object newInstance(Class<?> componentType, int... dimensions)
+  // public static Object newInstance(Class<?> componentType, int length)
+
+  private Array() {
+  }
+}
diff --git a/user/test/com/google/gwt/emultest/EmulSuite.java b/user/test/com/google/gwt/emultest/EmulSuite.java
index 483ae7a..155d866 100644
--- a/user/test/com/google/gwt/emultest/EmulSuite.java
+++ b/user/test/com/google/gwt/emultest/EmulSuite.java
@@ -41,6 +41,7 @@
 import com.google.gwt.emultest.java.lang.ThrowableStackTraceEmulTest;
 import com.google.gwt.emultest.java.lang.ThrowableTest;
 import com.google.gwt.emultest.java.lang.TypeTest;
+import com.google.gwt.emultest.java.lang.reflect.ArrayTest;
 import com.google.gwt.emultest.java.math.MathContextTest;
 import com.google.gwt.emultest.java.math.MathContextWithObfuscatedEnumsTest;
 import com.google.gwt.emultest.java.math.RoundingModeTest;
@@ -91,6 +92,9 @@
   ThrowableStackTraceEmulTest.class,
   TypeTest.class,
 
+  // java.lang.reflect
+  ArrayTest.class,
+
   //-- java.math
   // BigDecimal is tested in {@link BigDecimalSuite}
   // BigInteger is tested in {@link BigIntegerSuite}
diff --git a/user/test/com/google/gwt/emultest/java/lang/reflect/ArrayTest.java b/user/test/com/google/gwt/emultest/java/lang/reflect/ArrayTest.java
new file mode 100644
index 0000000..420248c
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/lang/reflect/ArrayTest.java
@@ -0,0 +1,450 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.emultest.java.lang.reflect;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+import java.lang.reflect.Array;
+
+/** Tests for java.lang.reflect.Array. */
+public final class ArrayTest extends GWTTestCase {
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.emultest.EmulSuite";
+  }
+
+  public void testGet() {
+    try {
+      Array.get(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.get(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals("1", Array.get(new Object[] {"1"}, 0));
+    assertEquals(Boolean.TRUE, Array.get(new boolean[] {true}, 0));
+    assertEquals(new Byte((byte) 1), Array.get(new byte[] {1}, 0));
+    assertEquals(new Character('1'), Array.get(new char[] {'1'}, 0));
+    assertEquals(new Double(1.0d), Array.get(new double[] {1}, 0));
+    assertEquals(new Float(1.0f), Array.get(new float[] {1.0f}, 0));
+    assertEquals(new Integer(1), Array.get(new int[] {1}, 0));
+    assertEquals(new Long(1L), Array.get(new long[] {1}, 0));
+    assertEquals(new Short((short) 1), Array.get(new short[] {1}, 0));
+  }
+
+  public void testGetBoolean() {
+    try {
+      Array.getBoolean(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getBoolean(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getBoolean(new Boolean[] {true}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertTrue(Array.getBoolean(new boolean[] {true}, 0));
+    assertFalse(Array.getBoolean(new boolean[] {false}, 0));
+    assertTrue(Array.getBoolean(new boolean[] {Boolean.TRUE}, 0));
+    assertFalse(Array.getBoolean(new boolean[] {Boolean.FALSE}, 0));
+  }
+
+  public void testGetByte() {
+    try {
+      Array.getByte(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getByte(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getByte(new Byte[] {(byte) 0}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0));
+    assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0));
+    assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0));
+    assertEquals((byte) 1, Array.getByte(new byte[] {(byte) 1}, 0));
+  }
+
+  public void testGetChar() {
+    try {
+      Array.getChar(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getChar(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getChar(new Character[] {'0'}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals('1', Array.getChar(new char[] {'1'}, 0));
+  }
+
+  public void testGetDouble() {
+    try {
+      Array.getDouble(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getDouble(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getDouble(new Double[] {0d}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals(1.0d, Array.getDouble(new double[] {1.0d}, 0));
+  }
+
+  public void testGetFloat() {
+    try {
+      Array.getFloat(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getFloat(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getFloat(new Float[] {0f}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals(1.0f, Array.getFloat(new float[] {1.0f}, 0));
+  }
+
+  public void testGetInt() {
+    try {
+      Array.getInt(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getInt(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getInt(new Integer[] {0}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals(1, Array.getInt(new int[] {1}, 0));
+  }
+
+  public void testGetLength() {
+    try {
+      Array.getLength(null);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+    assertEquals(0, Array.getLength(new Object[0]));
+    assertEquals(1, Array.getLength(new Object[1]));
+
+    assertEquals(0, Array.getLength(new int[0]));
+    assertEquals(1, Array.getLength(new int[1]));
+  }
+
+  public void testGetLong() {
+    try {
+      Array.getLong(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getLong(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getLong(new Long[] {0L}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals(1L, Array.getLong(new long[] {1L}, 0));
+  }
+
+  public void testGetShort() {
+    try {
+      Array.getShort(null, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getShort(new Object(), 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.getShort(new Short[] {(short) 1}, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    assertEquals((short) 1, Array.getShort(new short[] {(short) 1}, 0));
+  }
+
+  public void testSet() {
+    try {
+      Array.set(null, 0, true);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.set(new Object(), 0, true);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    Object[] objectArray = new Object[1];
+    Array.set(objectArray, 0, "1");
+    assertEquals("1", objectArray[0]);
+
+    boolean[] booleanArray = new boolean[1];
+    Array.set(booleanArray, 0, true);
+    assertTrue(booleanArray[0]);
+
+    byte[] byteArray = new byte[1];
+    Array.set(byteArray, 0, (byte) 1);
+    assertEquals((byte) 1, byteArray[0]);
+
+    char[] charArray = new char[1];
+    Array.set(charArray, 0, 'a');
+    assertEquals('a', charArray[0]);
+
+    double[] doubleArray = new double[1];
+    Array.set(doubleArray, 0, 1.0d);
+    assertEquals(1.0d, doubleArray[0]);
+
+    float[] floatArray = new float[1];
+    Array.set(floatArray, 0, 1.0f);
+    assertEquals(1.0f, floatArray[0]);
+
+    int[] intArray = new int[1];
+    Array.set(intArray, 0, 1);
+    assertEquals(1, intArray[0]);
+
+    long[] longArray = new long[1];
+    Array.set(longArray, 0, 1L);
+    assertEquals(1L, longArray[0]);
+
+    short[] shortArray = new short[1];
+    Array.set(shortArray, 0, (short) 1);
+    assertEquals((short) 1, shortArray[0]);
+  }
+
+  public void testSetBoolean() {
+    try {
+      Array.setBoolean(null, 0, true);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setBoolean(new Object(), 0, true);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    boolean[] array = new boolean[1];
+
+    Array.setBoolean(array, 0, true);
+    assertTrue(array[0]);
+  }
+
+  public void testSetByte() {
+    try {
+      Array.setByte(null, 0, (byte) 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setByte(new Object(), 0, (byte) 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    byte[] array = new byte[1];
+
+    Array.setByte(array, 0, (byte) 1);
+    assertEquals((byte) 1, array[0]);
+  }
+
+  public void testSetChar() {
+    try {
+      Array.setChar(null, 0, 'a');
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setChar(new Object(), 0, 'a');
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    char[] array = new char[1];
+
+    Array.setChar(array, 0, 'a');
+    assertEquals('a', array[0]);
+  }
+
+  public void testSetDouble() {
+    try {
+      Array.setDouble(null, 0, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setDouble(new Object(), 0, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    double[] array = new double[1];
+
+    Array.setDouble(array, 0, 1d);
+    assertEquals(1d, array[0]);
+  }
+
+  public void testSetFloat() {
+    try {
+      Array.setFloat(null, 0, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setFloat(new Object(), 0, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    float[] array = new float[1];
+
+    Array.setFloat(array, 0, 1.0f);
+    assertEquals(1.0f, array[0]);
+  }
+
+  public void testSetInt() {
+    try {
+      Array.setInt(null, 0, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setInt(new Object(), 0, 0);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    int[] array = new int[1];
+
+    Array.setInt(array, 0, 1);
+    assertEquals(1, array[0]);
+  }
+
+  public void testSetLong() {
+    try {
+      Array.setLong(null, 0, 0L);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setLong(new Object(), 0, 0L);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    long[] array = new long[1];
+
+    Array.setLong(array, 0, 1L);
+    assertEquals(1L, array[0]);
+  }
+
+  public void testSetShort() {
+    try {
+      Array.setShort(null, 0, (short) 1);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    try {
+      Array.setShort(new Object(), 0, (short) 1);
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    short[] array = new short[1];
+
+    Array.setShort(array, 0, (short) 1);
+    assertEquals((short) 1, array[0]);
+  }
+}