--- /dev/null	2013-02-24 18:12:51.832474922 -0800
+++ new/src/share/classes/java/util/OptionalInt.java	2013-03-04 12:18:50.773001557 -0800
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package java.util;
+
+import java.util.function.IntConsumer;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
+
+/**
+ * A container object which may or may not contain a {@code int} value.
+ * If a value is present, {@code isPresent()} will return {@code true} and
+ * {@code get()} will return the value.
+ *
+ * <p>Additional methods that depend on the presence or absence of a contained
+ * value are provided, such as {@link #orElse(java.lang.Object) orElse()}
+ * (return a default value if value not present) and
+ * {@link #ifPresent(java.util.function.Consumer) ifPresent()} (execute a block
+ * of code if the value is present.)
+ *
+ * @since 1.8
+ */
+public final class OptionalInt {
+    /**
+     * Common instance for {@code empty()}.
+     */
+    private final static OptionalInt EMPTY = new OptionalInt();
+
+    /**
+     * If true then the value is present, otherwise indicates no value is present
+     */
+    private final boolean isPresent;
+    private final int value;
+
+    /**
+     * Construct a non-empty instance
+     *
+     * @param value the int value to be present.
+     */
+    private OptionalInt(int value) {
+        this.isPresent = true;
+        this.value = value;
+    }
+
+    /**
+     * Construct an empty instance.
+     *
+     * @implNote generally only one empty instance, {@link OptionalInt#EMPTY},
+     * should exist per VM.
+     */
+    private OptionalInt() {
+        this.isPresent = false;
+        this.value = 0;
+    }
+
+    /**
+     * Return an empty {@code OptionalInt}.  No value is present for this Optional.
+     *
+     * @apiNote Though it may be tempting to do so, avoid testing if an object
+     * is empty by comparing with {@code ==} against instances returned
+     * {@code Option.empty()}. There is no guarantee that it is a singleton.
+     * Instead, use {@code isPresent()}.
+     *
+     *  @return an empty {@code OptionalInt}.
+     */
+    @SuppressWarnings("unchecked")
+    public static OptionalInt empty() {
+        return EMPTY;
+    }
+
+    /**
+     * Create a new {@code OptionalInt} with a present value
+     * @param value The int value
+     * @param value new {@code OptionalInt} with a present value.
+     */
+    public static OptionalInt of(int value) {
+        return new OptionalInt(value);
+    }
+
+    /**
+     * If a value is present in this {@code OptionalInt}, returns the value,
+     * otherwise throws {@code NoSuchElementException}.
+     *
+     * @return the value held by this {@code OptionalInt}.
+     * @throws NoSuchElementException if there is no value present.
+     *
+     * @see OptionalInt#isPresent()
+     */
+    public int getAsInt() {
+        if (!isPresent) {
+            throw new NoSuchElementException("No value present");
+        }
+        return value;
+    }
+
+    /**
+     * Return {@code true} if there is a value present, otherwise {@code false}.
+     *
+     * @return {@code true} if there is a value present, otherwise {@code false}.
+     */
+    public boolean isPresent() {
+        return isPresent;
+    }
+
+    /**
+     * Execute the specified consumer with the value if a value is present,
+     * otherwise do nothing.
+     *
+     * @param consumer block to be executed if a value is present.
+     * @throws NullPointerException if value is present and {@code consumer} is
+     * null.
+     */
+    public void ifPresent(IntConsumer consumer) {
+        if (isPresent)
+            consumer.accept(value);
+    }
+
+    /**
+     * Return the value if present, otherwise return {@code other}.
+     *
+     * @param other value to be returned if there is no value present.
+     * @return the value, if present, otherwise {@code other}.
+     */
+    public int orElse(int other) {
+        return isPresent ? value : other;
+    }
+
+    /**
+     * Return the value if present, otherwise invoke {@code other} and return
+     * the result of that invocation.
+     *
+     * @param other {@code IntSupplier} who's result is returned if there is no
+     * value present.
+     * @return the value if present otherwise return result of {@code other}.
+     * @throws NullPointerException if value is absent and {@code other} is null.
+     */
+    public int orElseGet(IntSupplier other) {
+        return isPresent ? value : other.getAsInt();
+    }
+
+    /**
+     * Return the contained value, if present, otherwise throw an exception
+     * to be created by the provided supplier.
+     *
+     * @param <V> Type of the exception to be thrown.
+     * @param exceptionSupplier The supplier which will return the exception to
+     * be thrown.
+     * @return the value.
+     * @throws V if there is no value present.
+     * @throws NullPointerException if value is absent and
+     * {@code exceptionSupplier} is null.
+     */
+    public<V extends Throwable> int orElseThrow(Supplier<V> exceptionSupplier) throws V {
+        if (isPresent) {
+            return value;
+        } else {
+            throw exceptionSupplier.get();
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (!(o instanceof OptionalInt)) {
+            return false;
+        }
+
+        OptionalInt other = (OptionalInt) o;
+        return (isPresent && other.isPresent) ? value == other.value : isPresent == other.isPresent;
+    }
+
+    @Override
+    public int hashCode() {
+        return Integer.hashCode(value);
+    }
+
+    @Override
+    public String toString() {
+        return isPresent
+			? String.format("IntOptional[%s]", value)
+			: "IntOptional.empty";
+    }
+}