कोई भी Eitherप्रकार जावा 8 नहीं है, इसलिए आपको खुद को बनाने या किसी तीसरे पक्ष के पुस्तकालय का उपयोग करने की आवश्यकता है।
आप नए Optionalप्रकार का उपयोग करके ऐसी सुविधा का निर्माण कर सकते हैं (लेकिन इस उत्तर के अंत में पढ़ें):
final class Either<L,R>
{
public static <L,R> Either<L,R> left(L value) {
return new Either<>(Optional.of(value), Optional.empty());
}
public static <L,R> Either<L,R> right(R value) {
return new Either<>(Optional.empty(), Optional.of(value));
}
private final Optional<L> left;
private final Optional<R> right;
private Either(Optional<L> l, Optional<R> r) {
left=l;
right=r;
}
public <T> T map(
Function<? super L, ? extends T> lFunc,
Function<? super R, ? extends T> rFunc)
{
return left.<T>map(lFunc).orElseGet(()->right.map(rFunc).get());
}
public <T> Either<T,R> mapLeft(Function<? super L, ? extends T> lFunc)
{
return new Either<>(left.map(lFunc),right);
}
public <T> Either<L,T> mapRight(Function<? super R, ? extends T> rFunc)
{
return new Either<>(left, right.map(rFunc));
}
public void apply(Consumer<? super L> lFunc, Consumer<? super R> rFunc)
{
left.ifPresent(lFunc);
right.ifPresent(rFunc);
}
}
उदाहरण उपयोग मामला:
new Random().ints(20, 0, 2).mapToObj(i -> (Either<String,Integer>)(i==0?
Either.left("left value (String)"):
Either.right(42)))
.forEach(either->either.apply(
left ->{ System.out.println("received left value: "+left.substring(11));},
right->{ System.out.println("received right value: 0x"+Integer.toHexString(right));}
));
पूर्वव्यापी में, Optionalआधारित समाधान एक शैक्षणिक उदाहरण की तरह है, लेकिन अनुशंसित दृष्टिकोण नहीं है। एक समस्या null"खाली" के रूप में है जो "या तो" के अर्थ का विरोध करती है।
निम्न कोड दिखाता है Eitherकि nullएक संभावित मूल्य पर विचार करता है, इसलिए यह कड़ाई से "या तो", बाएं या दाएं, भले ही मूल्य है null:
abstract class Either<L,R>
{
public static <L,R> Either<L,R> left(L value) {
return new Either<L,R>() {
@Override public <T> T map(Function<? super L, ? extends T> lFunc,
Function<? super R, ? extends T> rFunc) {
return lFunc.apply(value);
}
};
}
public static <L,R> Either<L,R> right(R value) {
return new Either<L,R>() {
@Override public <T> T map(Function<? super L, ? extends T> lFunc,
Function<? super R, ? extends T> rFunc) {
return rFunc.apply(value);
}
};
}
private Either() {}
public abstract <T> T map(
Function<? super L, ? extends T> lFunc, Function<? super R, ? extends T> rFunc);
public <T> Either<T,R> mapLeft(Function<? super L, ? extends T> lFunc) {
return this.<Either<T,R>>map(t -> left(lFunc.apply(t)), t -> (Either<T,R>)this);
}
public <T> Either<L,T> mapRight(Function<? super R, ? extends T> lFunc) {
return this.<Either<L,T>>map(t -> (Either<L,T>)this, t -> right(lFunc.apply(t)));
}
public void apply(Consumer<? super L> lFunc, Consumer<? super R> rFunc) {
map(consume(lFunc), consume(rFunc));
}
private <T> Function<T,Void> consume(Consumer<T> c) {
return t -> { c.accept(t); return null; };
}
}
दोनों फैक्ट्री के तरीकों की शुरुआत में nullकेवल एक सख्त अस्वीकृति के साथ इसे बदलना आसान है Objects.requireNonNull(value)। इसी तरह, खाली के लिए समर्थन जोड़ना या तो कल्पना करना उचित होगा।