diff --git a/src/com/android/xsdc/java/JavaCodeGenerator.java b/src/com/android/xsdc/java/JavaCodeGenerator.java
index aee83b5..0ab6198 100644
--- a/src/com/android/xsdc/java/JavaCodeGenerator.java
+++ b/src/com/android/xsdc/java/JavaCodeGenerator.java
@@ -157,7 +157,7 @@
             XsdElement element = complexType.getElements().get(i);
             XsdElement elementValue = resolveElement(element);
             String typeName = element.isMultiple() ? String.format("java.util.List<%s>",
-                    type.getName()) : type.getName();
+                    type.getNullableName()) : type.getName();
             out.printf("private %s %s;\n", typeName, Utils.toVariableName(elementValue.getName()));
         }
         for (int i = 0; i < attributeTypes.size(); ++i) {
@@ -175,17 +175,16 @@
             JavaType type = elementTypes.get(i);
             XsdElement element = complexType.getElements().get(i);
             XsdElement elementValue = resolveElement(element);
-            printGetterAndSetter(out, type.getName(), Utils.toVariableName(elementValue.getName()),
+            printGetterAndSetter(out, type, Utils.toVariableName(elementValue.getName()),
                     element.isMultiple());
         }
         for (int i = 0; i < attributeTypes.size(); ++i) {
             JavaType type = attributeTypes.get(i);
             XsdAttribute attribute = resolveAttribute(complexType.getAttributes().get(i));
-            printGetterAndSetter(out, type.getName(), Utils.toVariableName(attribute.getName()),
-                    false);
+            printGetterAndSetter(out, type, Utils.toVariableName(attribute.getName()), false);
         }
         if (valueType != null) {
-            printGetterAndSetter(out, valueType.getName(), "value", false);
+            printGetterAndSetter(out, valueType, "value", false);
         }
 
         out.println();
@@ -271,10 +270,10 @@
                 + "}\n");
     }
 
-    private void printGetterAndSetter(CodeWriter out, String singleTypeName, String variableName,
+    private void printGetterAndSetter(CodeWriter out, JavaType type, String variableName,
             boolean isMultiple) {
-        String typeName = isMultiple ? String.format("java.util.List<%s>", singleTypeName)
-                : singleTypeName;
+        String typeName = isMultiple ? String.format("java.util.List<%s>", type.getNullableName())
+                : type.getName();
         out.println();
         out.printf("public %s get%s() {\n", typeName, Utils.capitalize(variableName));
         if (isMultiple) {
@@ -562,21 +561,26 @@
                         false);
             case "long":
             case "unsignedInt":
-                return new JavaSimpleType("java.lang.Long", "Long.valueOf(%s)", false);
+                return new JavaSimpleType("long", "java.lang.Long", "Long.parseLong(%s)", false);
             case "int":
             case "unsignedShort":
-                return new JavaSimpleType("java.lang.Integer", "Integer.valueOf(%s)", false);
+                return new JavaSimpleType("int", "java.lang.Integer", "Integer.parseInt(%s)",
+                        false);
             case "short":
             case "unsignedByte":
-                return new JavaSimpleType("java.lang.Short", "Short.valueOf(%s)", false);
+                return new JavaSimpleType("short", "java.lang.Short", "Short.parseShort(%s)",
+                        false);
             case "byte":
-                return new JavaSimpleType("java.lang.Byte", "Byte.valueOf(%s)", false);
+                return new JavaSimpleType("byte", "java.lang.Byte", "Byte.parseByte(%s)", false);
             case "boolean":
-                return new JavaSimpleType("java.lang.Boolean", "Boolean.valueOf(%s)", false);
+                return new JavaSimpleType("boolean", "java.lang.Boolean",
+                        "Boolean.parseBoolean(%s)", false);
             case "double":
-                return new JavaSimpleType("java.lang.Double", "Double.valueOf(%s)", false);
+                return new JavaSimpleType("double", "java.lang.Double", "Double.parseDouble(%s)",
+                        false);
             case "float":
-                return new JavaSimpleType("java.lang.Float", "Float.valueOf(%s)", false);
+                return new JavaSimpleType("float", "java.lang.Float", "Float.parseFloat(%s)",
+                        false);
             case "base64Binary":
                 return new JavaSimpleType("byte[]", "java.util.Base64.getDecoder().decode(%s)",
                         false);
diff --git a/src/com/android/xsdc/java/JavaComplexType.java b/src/com/android/xsdc/java/JavaComplexType.java
index 6c52a45..c0c694a 100644
--- a/src/com/android/xsdc/java/JavaComplexType.java
+++ b/src/com/android/xsdc/java/JavaComplexType.java
@@ -29,6 +29,11 @@
     }
 
     @Override
+    public String getNullableName() {
+        return name;
+    }
+
+    @Override
     public String getParsingExpression() {
         return String.format("%s value = %s.read(parser);\n", name, name);
     }
diff --git a/src/com/android/xsdc/java/JavaSimpleType.java b/src/com/android/xsdc/java/JavaSimpleType.java
index eb9be87..4aac0d1 100644
--- a/src/com/android/xsdc/java/JavaSimpleType.java
+++ b/src/com/android/xsdc/java/JavaSimpleType.java
@@ -18,13 +18,23 @@
 
 class JavaSimpleType implements JavaType {
     final private String name;
+    final private String nullableName;
     final private String rawParsingExpression;
     final private boolean list;
+    final private String fullName;
+    final private String nullableFullName;
 
-    JavaSimpleType(String name, String rawParsingExpression, boolean list) {
+    JavaSimpleType(String name, String nullableName, String rawParsingExpression, boolean list) {
         this.name = name;
+        this.nullableName = nullableName;
         this.rawParsingExpression = rawParsingExpression;
         this.list = list;
+        fullName = list ? String.format("java.util.List<%s>", nullableName) : name;
+        nullableFullName = list ? String.format("java.util.List<%s>", nullableName) : nullableName;
+    }
+
+    JavaSimpleType(String name, String rawParsingExpression, boolean list) {
+        this(name, name, rawParsingExpression, list);
     }
 
     boolean isList() {
@@ -33,12 +43,17 @@
 
     JavaSimpleType newListType() throws JavaCodeGeneratorException {
         if (list) throw new JavaCodeGeneratorException("list of list is not supported");
-        return new JavaSimpleType(name, rawParsingExpression, true);
+        return new JavaSimpleType(name, nullableName, rawParsingExpression, true);
     }
 
     @Override
     public String getName() {
-        return list ? String.format("java.util.List<%s>", name) : name;
+        return fullName;
+    }
+
+    @Override
+    public String getNullableName() {
+        return nullableFullName;
     }
 
     @Override
diff --git a/src/com/android/xsdc/java/JavaType.java b/src/com/android/xsdc/java/JavaType.java
index fe85fd7..a0de172 100644
--- a/src/com/android/xsdc/java/JavaType.java
+++ b/src/com/android/xsdc/java/JavaType.java
@@ -19,5 +19,9 @@
 interface JavaType {
     String getName();
 
+    // It is used to make a list type. (List<?>)
+    // getName() can be a primitive type, but getNullableName() cannot be.
+    String getNullableName();
+
     String getParsingExpression();
 }
diff --git a/tests/resources/predefined_types.xml b/tests/resources/predefined_types.xml
index 37bc168..940a313 100644
--- a/tests/resources/predefined_types.xml
+++ b/tests/resources/predefined_types.xml
@@ -52,4 +52,13 @@
         <IDREFS>abcd abcd</IDREFS>
         <anyType>abcd</anyType>
     </miscTypes>
+    <listPrimitiveTypes>
+        <listLong>-9223372036854775808 9223372036854775807</listLong>
+        <listInt>-2147483648 2147483647</listInt>
+        <listShort>-32768 32767</listShort>
+        <listByte>-128 127</listByte>
+        <listDouble>1234.5678 5678.1234</listDouble>
+        <listFloat>123.456 456.123</listFloat>
+        <listBoolean>true false</listBoolean>
+    </listPrimitiveTypes>
 </types>
\ No newline at end of file
diff --git a/tests/resources/predefined_types.xsd b/tests/resources/predefined_types.xsd
index 35296c2..819f7fb 100644
--- a/tests/resources/predefined_types.xsd
+++ b/tests/resources/predefined_types.xsd
@@ -59,6 +59,45 @@
             <xs:element name="anyType" type="xs:anyType"/>
         </xs:sequence>
     </xs:complexType>
+    <xs:complexType name="listPrimitiveTypes">
+        <xs:sequence>
+            <xs:element name="listLong">
+                <xs:simpleType>
+                    <xs:list itemType="xs:long"/>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="listInt">
+                <xs:simpleType>
+                    <xs:list itemType="xs:int"/>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="listShort">
+                <xs:simpleType>
+                    <xs:list itemType="xs:short"/>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="listByte">
+                <xs:simpleType>
+                    <xs:list itemType="xs:byte"/>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="listDouble">
+                <xs:simpleType>
+                    <xs:list itemType="xs:double"/>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="listFloat">
+                <xs:simpleType>
+                    <xs:list itemType="xs:float"/>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="listBoolean">
+                <xs:simpleType>
+                    <xs:list itemType="xs:boolean"/>
+                </xs:simpleType>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
     <xs:element name="types">
         <xs:complexType>
             <xs:sequence>
@@ -66,6 +105,7 @@
                 <xs:element name="dateTypes" type="dateTypes"/>
                 <xs:element name="numericTypes" type="numericTypes"/>
                 <xs:element name="miscTypes" type="miscTypes"/>
+                <xs:element name="listPrimitiveTypes" type="listPrimitiveTypes"/>
             </xs:sequence>
         </xs:complexType>
     </xs:element>
diff --git a/tests/src/com/android/xsdc/tests/XmlParserTest.java b/tests/src/com/android/xsdc/tests/XmlParserTest.java
index ba4f44e..29b02a0 100644
--- a/tests/src/com/android/xsdc/tests/XmlParserTest.java
+++ b/tests/src/com/android/xsdc/tests/XmlParserTest.java
@@ -165,6 +165,7 @@
         Class<?> dateTypes = result.loadClass("DateTypes");
         Class<?> numericTypes = result.loadClass("NumericTypes");
         Class<?> miscTypes = result.loadClass("MiscTypes");
+        Class<?> listPrimitiveTypes = result.loadClass("ListPrimitiveTypes");
 
         Object instance;
         try (InputStream in = this.getClass().getClassLoader().getResourceAsStream(
@@ -306,6 +307,33 @@
             assertThat(iDREFS, is(Arrays.asList("abcd", "abcd")));
             assertThat(anyType, is("abcd"));
         }
+
+        {
+            Object listPrimitiveTypesInstance = types.getMethod("getListPrimitiveTypes").invoke(
+                    instance);
+            List listLong = (List) listPrimitiveTypes.getMethod("getListLong").invoke(
+                    listPrimitiveTypesInstance);
+            List listInt = (List) listPrimitiveTypes.getMethod("getListInt").invoke(
+                    listPrimitiveTypesInstance);
+            List listShort = (List) listPrimitiveTypes.getMethod("getListShort").invoke(
+                    listPrimitiveTypesInstance);
+            List listByte = (List) listPrimitiveTypes.getMethod("getListByte").invoke(
+                    listPrimitiveTypesInstance);
+            List listDouble = (List) listPrimitiveTypes.getMethod("getListDouble").invoke(
+                    listPrimitiveTypesInstance);
+            List listFloat = (List) listPrimitiveTypes.getMethod("getListFloat").invoke(
+                    listPrimitiveTypesInstance);
+            List listBoolean = (List) listPrimitiveTypes.getMethod("getListBoolean").invoke(
+                    listPrimitiveTypesInstance);
+
+            assertThat(listLong, is(Arrays.asList(-9223372036854775808L, 9223372036854775807L)));
+            assertThat(listInt, is(Arrays.asList(-2147483648, 2147483647)));
+            assertThat(listShort, is(Arrays.asList((short) -32768, (short) 32767)));
+            assertThat(listByte, is(Arrays.asList((byte) -128, (byte) 127)));
+            assertThat(listDouble, is(Arrays.asList(1234.5678, 5678.1234)));
+            assertThat(listFloat, is(Arrays.asList(123.456f, 456.123f)));
+            assertThat(listBoolean, is(Arrays.asList(true, false)));
+        }
     }
 
     @Test