diff --git a/src/main/java/org/apache/sling/models/impl/injectors/ValueMapInjector.java b/src/main/java/org/apache/sling/models/impl/injectors/ValueMapInjector.java
index f24b367..92036f7 100644
--- a/src/main/java/org/apache/sling/models/impl/injectors/ValueMapInjector.java
+++ b/src/main/java/org/apache/sling/models/impl/injectors/ValueMapInjector.java
@@ -23,6 +23,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 
 import org.apache.commons.lang3.ClassUtils;
 import org.apache.commons.lang3.ObjectUtils;
@@ -98,6 +99,11 @@
                 return null;
             }
             Class<?> collectionType = (Class<?>) pType.getRawType();
+
+            if (collectionType.equals(Optional.class)) {
+                return Optional.ofNullable(map.get(name));
+            }
+
             if (!(collectionType.equals(Collection.class) || collectionType.equals(List.class))) {
                 return null;
             }
diff --git a/src/test/java/org/apache/sling/models/impl/OptionalObjectsTest.java b/src/test/java/org/apache/sling/models/impl/OptionalObjectsTest.java
new file mode 100644
index 0000000..13a63b6
--- /dev/null
+++ b/src/test/java/org/apache/sling/models/impl/OptionalObjectsTest.java
@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.sling.models.impl;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.api.resource.ValueMap;
+import org.apache.sling.api.wrappers.ValueMapDecorator;
+import org.apache.sling.models.impl.injectors.ValueMapInjector;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.runners.MockitoJUnitRunner;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class OptionalObjectsTest {
+
+    private ModelAdapterFactory factory;
+
+    @Before
+    public void setup() {
+        factory = AdapterFactoryTest.createModelAdapterFactory();
+        factory.bindInjector(new ValueMapInjector(), new ServicePropertiesMap(2, 2));
+        factory.adapterImplementations.addClassesAsAdapterAndImplementation(
+                org.apache.sling.models.testmodels.classes.OptionalObjectsModel.class);
+    }
+
+    @Test
+    public void testFieldInjectionClass() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("optionalString", "foo bar baz");
+        map.put("optionalByte", Byte.valueOf("1"));
+        map.put("optionalInteger", Integer.valueOf("1"));
+        map.put("optionalShort", Short.valueOf("1"));
+        map.put("optionalLong", Long.valueOf("1"));
+        map.put("optionalShort", Short.valueOf("1"));
+        map.put("optionalDouble", Double.valueOf("1"));
+        map.put("optionalFloat", Float.valueOf("1"));
+        map.put("optionalChar", '1');
+        map.put("optionalBoolean", Boolean.valueOf("true"));
+        map.put("optionalList", Arrays.asList("foo", "bar", "baz"));
+        map.put("optionalArray", new String[]{"qux", "quux"});
+
+        Resource res = mock(Resource.class);
+        when(res.adaptTo(ValueMap.class)).thenReturn(new ValueMapDecorator(map));
+
+        org.apache.sling.models.testmodels.classes.OptionalObjectsModel model = factory.getAdapter(res,
+                org.apache.sling.models.testmodels.classes.OptionalObjectsModel.class);
+        assertNotNull(model);
+
+        assertEquals(Optional.of("foo bar baz"), model.getOptionalString());
+        assertEquals(Optional.empty(), model.getOptionalNullString());
+
+        assertEquals(Optional.of(1), model.getOptionalInteger());
+        assertEquals(Optional.empty(), model.getOptionalNullInteger());
+
+        assertEquals(Optional.of(Byte.valueOf("1")), model.getOptionalByte());
+        assertEquals(Optional.empty(), model.getOptionalNullByte());
+
+        assertEquals(Optional.of(Long.valueOf("1")), model.getOptionalLong());
+        assertEquals(Optional.empty(), model.getOptionalNullLong());
+
+        assertEquals(Optional.of(Short.valueOf("1")), model.getOptionalShort());
+        assertEquals(Optional.empty(), model.getOptionalNullShort());
+
+        assertEquals(Optional.of(Double.valueOf("1")), model.getOptionalDouble());
+        assertEquals(Optional.empty(), model.getOptionalNullDouble());
+
+        assertEquals(Optional.of(Float.valueOf("1")), model.getOptionalFloat());
+        assertEquals(Optional.empty(), model.getOptionalNullFloat());
+
+        assertEquals(Optional.of(1L), model.getOptionalLong());
+        assertEquals(Optional.empty(), model.getOptionalNullLong());
+
+        assertEquals(Optional.of('1'), model.getOptionalChar());
+        assertEquals(Optional.empty(), model.getOptionalNullChar());
+
+        assertEquals(Optional.of(Boolean.valueOf("true")), model.getOptionalBoolean());
+        assertEquals(Optional.empty(), model.getOptionalNullBoolean());
+
+        assertEquals(Optional.of(Arrays.asList("foo", "bar", "baz")), model.getOptionalList());
+        assertEquals(Optional.empty(), model.getOptionalNullList());
+
+        assertTrue(model.getOptionalArray().isPresent());
+        assertTrue("qux".equalsIgnoreCase(model.getOptionalArray().get()[0]));
+        assertTrue("quux".equalsIgnoreCase(model.getOptionalArray().get()[1]));
+        assertEquals(Optional.empty(), model.getOptionalNullArray());
+    }
+}
diff --git a/src/test/java/org/apache/sling/models/testmodels/classes/OptionalObjectsModel.java b/src/test/java/org/apache/sling/models/testmodels/classes/OptionalObjectsModel.java
new file mode 100644
index 0000000..a130e3d
--- /dev/null
+++ b/src/test/java/org/apache/sling/models/testmodels/classes/OptionalObjectsModel.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.sling.models.testmodels.classes;
+
+import java.util.Collection;
+import java.util.Optional;
+import javax.inject.Inject;
+
+import org.apache.sling.api.resource.Resource;
+import org.apache.sling.models.annotations.Model;
+
+@Model(adaptables = Resource.class)
+public class OptionalObjectsModel {
+
+    @Inject
+    private Optional<String> optionalString;
+
+    @Inject
+    private Optional<String> optionalNullString;
+
+    @Inject
+    private Optional<Byte> optionalByte;
+
+    @Inject
+    private Optional<Byte> optionalNullByte;
+
+    @Inject
+    private Optional<Short> optionalShort;
+
+    @Inject
+    private Optional<Short> optionalNullShort;
+
+    @Inject
+    private Optional<Integer> optionalInteger;
+
+    @Inject
+    private Optional<Integer> optionalNullInteger;
+
+    @Inject
+    private Optional<Long> optionalLong;
+
+    @Inject
+    private Optional<Long> optionalNullLong;
+
+    @Inject
+    private Optional<Float> optionalFloat;
+
+    @Inject
+    private Optional<Float> optionalNullFloat;
+
+    @Inject
+    private Optional<Double> optionalDouble;
+
+    @Inject
+    private Optional<Double> optionalNullDouble;
+
+    @Inject
+    private Optional<Character> optionalChar;
+
+    @Inject
+    private Optional<Character> optionalNullChar;
+
+    @Inject
+    private Optional<Boolean> optionalBoolean;
+
+    @Inject
+    private Optional<Boolean> optionalNullBoolean;
+
+    @Inject
+    private Optional<? extends Collection> optionalList;
+
+    @Inject
+    private Optional<? extends Collection> optionalNullList;
+
+    @Inject
+    private Optional<String[]> optionalArray;
+
+    @Inject
+    private Optional<String[]> optionalNullArray;
+
+    public Optional<String> getOptionalString() {
+        return optionalString;
+    }
+
+    public Optional<String> getOptionalNullString() {
+        return optionalNullString;
+    }
+
+    public Optional<Byte> getOptionalByte() {
+        return optionalByte;
+    }
+
+    public Optional<Byte> getOptionalNullByte() {
+        return optionalNullByte;
+    }
+
+    public Optional<Short> getOptionalShort() {
+        return optionalShort;
+    }
+
+    public Optional<Short> getOptionalNullShort() {
+        return optionalNullShort;
+    }
+
+    public Optional<Integer> getOptionalInteger() {
+        return optionalInteger;
+    }
+
+    public Optional<Integer> getOptionalNullInteger() {
+        return optionalNullInteger;
+    }
+
+    public Optional<Long> getOptionalLong() {
+        return optionalLong;
+    }
+
+    public Optional<Long> getOptionalNullLong() {
+        return optionalNullLong;
+    }
+
+    public Optional<Float> getOptionalFloat() {
+        return optionalFloat;
+    }
+
+    public Optional<Float> getOptionalNullFloat() {
+        return optionalNullFloat;
+    }
+
+    public Optional<Double> getOptionalDouble() {
+        return optionalDouble;
+    }
+
+    public Optional<Double> getOptionalNullDouble() {
+        return optionalNullDouble;
+    }
+
+    public Optional<Character> getOptionalChar() {
+        return optionalChar;
+    }
+
+    public Optional<Character> getOptionalNullChar() {
+        return optionalNullChar;
+    }
+
+    public Optional<Boolean> getOptionalBoolean() {
+        return optionalBoolean;
+    }
+
+    public Optional<Boolean> getOptionalNullBoolean() {
+        return optionalNullBoolean;
+    }
+
+    public Optional<? extends Collection> getOptionalList() {
+        return optionalList;
+    }
+
+    public Optional<? extends Collection> getOptionalNullList() {
+        return optionalNullList;
+    }
+
+    public Optional<String[]> getOptionalArray() {
+        return optionalArray;
+    }
+
+    public Optional<String[]> getOptionalNullArray() {
+        return optionalNullArray;
+    }
+}