diff --git a/src/class_linker.cc b/src/class_linker.cc
index 92bb6d4..0a0bb04 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -137,6 +137,14 @@
                                               sizeof(Method)));
 }
 
+String* ClassLinker::AllocStringFromModifiedUtf8(int32_t utf16_length,
+                                                 const char* utf8_data_in) {
+  return String::AllocFromModifiedUtf8(java_lang_String_,
+                                       char_array_class_,
+                                       utf16_length,
+                                       utf8_data_in);
+}
+
 Class* ClassLinker::FindClass(const StringPiece& descriptor,
                               Object* class_loader,
                               const DexFile* dex_file) {
@@ -1497,10 +1505,9 @@
                                    uint32_t string_idx) {
   const DexFile* dex_file = FindDexFile(referring->GetDexCache());
   const DexFile::StringId& string_id = dex_file->GetStringId(string_idx);
-  const char* string_data = dex_file->GetStringData(string_id);
-  String* new_string = String::AllocFromModifiedUtf8(java_lang_String_,
-                                                     char_array_class_,
-                                                     string_data);
+  int32_t utf16_length = dex_file->GetStringLength(string_id);
+  const char* utf8_data = dex_file->GetStringData(string_id);
+  String* new_string = AllocStringFromModifiedUtf8(utf16_length, utf8_data);
   // TODO: intern the new string
   referring->GetDexCache()->SetResolvedString(string_idx, new_string);
   return new_string;
diff --git a/src/class_linker.h b/src/class_linker.h
index 738979b..46d4b1f 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -23,12 +23,15 @@
 
   ~ClassLinker() {}
 
+  // Alloc* convenience functions to avoid needing to pass in Class*
+  // values that are known to the ClassLinker such as
+  // object_array_class_ and java_lang_String_ etc.
   DexCache* AllocDexCache();
   Class* AllocClass(DexCache* dex_cache);
   StaticField* AllocStaticField();
   InstanceField* AllocInstanceField();
   Method* AllocMethod();
-
+  String* AllocStringFromModifiedUtf8(int32_t utf16_length, const char* utf8_data_in);
   template <class T>
   ObjectArray<T>* AllocObjectArray(size_t length) {
     return ObjectArray<T>::Alloc(object_array_class_, length);
diff --git a/src/dex_file.h b/src/dex_file.h
index 63fefae..c8f8afa 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -377,7 +377,7 @@
     const byte* ptr = base_ + string_id.string_data_off_;
     // Skip the uleb128 length.
     while (*(ptr++) > 0x7f) /* empty */ ;
-    return (const char*) ptr;
+    return reinterpret_cast<const char*>(ptr);
   }
 
   // return the UTF-8 encoded string with the specified string_id index
diff --git a/src/object.h b/src/object.h
index 77eb164..0abf444 100644
--- a/src/object.h
+++ b/src/object.h
@@ -607,12 +607,12 @@
   }
 
   T* Get(uint32_t i) const {
-    DCHECK_LT(i, GetLength());
+    CHECK_LT(i, GetLength());
     Object* const * data = reinterpret_cast<Object* const *>(GetData());
     return down_cast<T*>(data[i]);
   }
   void Set(uint32_t i, T* object) {
-    DCHECK_LT(i, GetLength());
+    CHECK_LT(i, GetLength());
     T** data = reinterpret_cast<T**>(GetData());
     data[i] = object;
   }
@@ -992,24 +992,53 @@
                                               length,
                                               sizeof(uint16_t)));
   }
+
+  uint16_t* GetChars() {
+    return reinterpret_cast<uint16_t*>(GetData());
+  }
+
+  const uint16_t* GetChars() const {
+    return reinterpret_cast<const uint16_t*>(GetData());
+  }
+
+  uint16_t GetChar(uint32_t i) const {
+    CHECK_LT(i, GetLength());
+    return GetChars()[i];
+  }
+
+  void  SetChar(uint32_t i, uint16_t ch) {
+    CHECK_LT(i, GetLength());
+    GetChars()[i] = ch;
+  }
+
  private:
   CharArray();
 };
 
 class String : public Object {
  public:
-  static String* Alloc(Class* java_lang_String) {
-    return down_cast<String*>(Object::Alloc(java_lang_String));
+  static String* AllocFromUtf16(Class* java_lang_String,
+                                Class* char_array,
+                                int32_t utf16_length,
+                                uint16_t* utf16_data_in) {
+    String* string = Alloc(java_lang_String, char_array, utf16_length);
+    uint16_t* utf16_data_out = string->array_->GetChars();
+    // TODO use 16-bit wide memset variant
+    for (int i = 0; i < utf16_length; i++ ) {
+        utf16_data_out[i] = utf16_data_in[i];
+    }
+    string->hash_code_ = ComputeUtf16Hash(utf16_data_out, utf16_length);
+    return string;
   }
 
   static String* AllocFromModifiedUtf8(Class* java_lang_String,
                                        Class* char_array,
-                                       const char* data) {
-    String* string = Alloc(java_lang_String);
-    uint32_t count = strlen(data);  // TODO
-    CharArray* array = CharArray::Alloc(char_array, count);
-    string->array_ = array;
-    string->count_ = count;
+                                       int32_t utf16_length,
+                                       const char* utf8_data_in) {
+    String* string = Alloc(java_lang_String, char_array, utf16_length);
+    uint16_t* utf16_data_out = string->array_->GetChars();
+    ConvertModifiedUtf8ToUtf16(utf16_data_out, utf8_data_in);
+    string->hash_code_ = ComputeUtf16Hash(utf16_data_out, utf16_length);
     return string;
   }
 
@@ -1022,6 +1051,65 @@
 
   uint32_t count_;
 
+  static String* Alloc(Class* java_lang_String,
+                       Class* char_array,
+                       int32_t utf16_length) {
+    String* string = down_cast<String*>(Object::Alloc(java_lang_String));
+    CharArray* array = CharArray::Alloc(char_array, utf16_length);
+    string->array_ = array;
+    string->count_ = utf16_length;
+    return string;
+  }
+
+  // Convert Modified UTF-8 to UTF-16
+  // http://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8
+  static void ConvertModifiedUtf8ToUtf16(uint16_t* utf16_data_out, const char* utf8_data_in) {
+    while (*utf8_data_in != '\0') {
+      *utf16_data_out++ = GetUtf16FromUtf8(&utf8_data_in);
+    }
+  }
+
+  // Retrieve the next UTF-16 character from a UTF-8 string.
+  //
+  // Advances "*pUtf8Ptr" to the start of the next character.
+  //
+  // WARNING: If a string is corrupted by dropping a '\0' in the middle
+  // of a 3-byte sequence, you can end up overrunning the buffer with
+  // reads (and possibly with the writes if the length was computed and
+  // cached before the damage). For performance reasons, this function
+  // assumes that the string being parsed is known to be valid (e.g., by
+  // already being verified). Most strings we process here are coming
+  // out of dex files or other internal translations, so the only real
+  // risk comes from the JNI NewStringUTF call.
+  static uint16_t GetUtf16FromUtf8(const char** utf8_data_in) {
+    uint8_t one = *(*utf8_data_in)++;
+    if ((one & 0x80) == 0) {
+      /* one-byte encoding */
+      return one;
+    }
+    /* two- or three-byte encoding */
+    uint8_t two = *(*utf8_data_in)++;
+    if ((one & 0x20) == 0) {
+      /* two-byte encoding */
+      return ((one & 0x1f) << 6) |
+              (two & 0x3f);
+    }
+    /* three-byte encoding */
+    uint8_t three = *(*utf8_data_in)++;
+    return ((one & 0x0f) << 12) |
+            ((two & 0x3f) << 6) |
+            (three & 0x3f);
+  }
+
+  // The java/lang/String.computeHashCode() algorithm
+  static uint32_t ComputeUtf16Hash(const uint16_t* string_data, size_t string_length) {
+    uint32_t hash = 0;
+    while (string_length--) {
+        hash = hash * 31 + *string_data++;
+    }
+    return hash;
+  }
+
  private:
   String();
 };
diff --git a/src/object_test.cc b/src/object_test.cc
index dc74b8b..969378c 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -8,12 +8,35 @@
 #include "object.h"
 #include "scoped_ptr.h"
 
+#include <stdint.h>
 #include <stdio.h>
 #include "gtest/gtest.h"
 
 namespace art {
 
-class ObjectTest : public RuntimeTest {};
+class ObjectTest : public RuntimeTest {
+ protected:
+  void AssertString(size_t length,
+                    const char* utf8_in,
+                    const char* utf16_expected_le,
+                    uint32_t hash_expected) {
+    uint16_t utf16_expected[length];
+    for (size_t i = 0; i < length; i++) {
+      uint16_t ch = (((utf16_expected_le[i*2 + 0] & 0xff) << 8) |
+                     ((utf16_expected_le[i*2 + 1] & 0xff) << 0));
+      utf16_expected[i] = ch;
+    }
+
+    String* string = class_linker_->AllocStringFromModifiedUtf8(length, utf8_in);
+    ASSERT_EQ(length, string->count_);
+    ASSERT_TRUE(string->array_ != NULL);
+    ASSERT_TRUE(string->array_->GetChars() != NULL);
+    for (size_t i = 0; i < length; i++) {
+      EXPECT_EQ(utf16_expected[i], string->array_->GetChar(i));
+    }
+    EXPECT_EQ(hash_expected, string->hash_code_);
+  }
+};
 
 TEST_F(ObjectTest, IsInSamePackage) {
   // Matches
@@ -42,4 +65,26 @@
     EXPECT_TRUE(oa->Get(1) == oa);
 }
 
+TEST_F(ObjectTest, String) {
+  // Test the empty string.
+  AssertString(0, "",     "", 0);
+
+  // Test one-byte characters.
+  AssertString(1, " ",    "\x00\x20",         0x20);
+  AssertString(1, "",     "\x00\x00",         0);
+  AssertString(1, "\x7f", "\x00\x7f",         0x7f);
+  AssertString(2, "hi",   "\x00\x68\x00\x69", (31 * 0x68) + 0x69);
+
+  // Test two-byte characters.
+  AssertString(1, "\xc2\x80",   "\x00\x80",                 0x80);
+  AssertString(1, "\xd9\xa6",   "\x06\x66",                 0x0666);
+  AssertString(1, "\xdf\xbf",   "\x07\xff",                 0x07ff);
+  AssertString(3, "h\xd9\xa6i", "\x00\x68\x06\x66\x00\x69", (31 * ((31 * 0x68) + 0x0666)) + 0x69);
+
+  // Test three-byte characters.
+  AssertString(1, "\xe0\xa0\x80",   "\x08\x00",                 0x0800);
+  AssertString(1, "\xe1\x88\xb4",   "\x12\x34",                 0x1234);
+  AssertString(1, "\xef\xbf\xbf",   "\xff\xff",                 0xffff);
+  AssertString(3, "h\xe1\x88\xb4i", "\x00\x68\x12\x34\x00\x69", (31 * ((31 * 0x68) + 0x1234)) + 0x69);
+}
 }  // namespace art