在使用Java 8可选类时，有两种方法可以将值包装在可选类中。

String foobar = <value or null>;
Optional.of(foobar);         // May throw NullPointerException
Optional.ofNullable(foobar); // Safe from NullPointerException

我明白可选的。ofNullable是唯一安全的使用Optional的方式，但是为什么Optional。存在吗?为什么不直接使用Optional呢?nullable和在任何时候都是安全的?

在我的Android应用中，我将用国际化实现我的字符串。我在语法和不同语言的句子结构方面有问题。

例如:

“5分钟前”-英语 vor 5 Minuten -德语

我可以在strings.xml中做如下的事情吗?

<string name="timeFormat">{0} minutes ago</string>

然后是魔法

getString(R.id.timeFormat, dynamicTimeValue)

这种行为也可以解决词序不同的问题。

我已经使用Java 8 6个多月了，我对新的API变化非常满意。我仍然不确定的一个领域是什么时候使用Optional。我似乎在想要在任何地方使用它之间摇摆，有些东西可能是空的，而根本没有。

似乎在很多情况下我都可以使用它，但我不确定它是否会增加好处(可读性/零安全性)，还是只会导致额外的开销。

所以，我有几个例子，我对社区对Optional是否有益的想法很感兴趣。

1 -当方法可以返回null时，作为一个公共方法返回类型:

public Optional<Foo> findFoo(String id);

2 -当参数可以为空时，作为方法参数:

public Foo doSomething(String id, Optional<Bar> barOptional);

3 -作为bean的可选成员:

public class Book {

  private List<Pages> pages;
  private Optional<Index> index;

}

4 -收集:

总的来说，我不认为:

List<Optional<Foo>>

添加任何东西-特别是因为一个人可以使用过滤器()删除空值等，但在集合中有任何可选的好用途吗?

有我错过的案子吗?

对于许多开发人员来说，Java 8中引入的可选类型是一个新事物。

是一个getter方法返回可选的<Foo>类型的地方，经典的Foo一个很好的实践?假设该值可以为空。

在Java 8中，我想对一个可选对象做一些事情，如果它是存在的，并做另一件事，如果它不存在。

if (opt.isPresent()) {
  System.out.println("found");
} else {
  System.out.println("Not found");
}

不过，这不是一种“功能性风格”。

Optional有一个ifPresent()方法，但我无法链orElse()方法。

因此，我不能写:

opt.ifPresent( x -> System.out.println("found " + x))
   .orElse( System.out.println("NOT FOUND"));

回复@assylias，我不认为Optional.map()适用于以下情况:

opt.map( o -> {
  System.out.println("while opt is present...");
  o.setProperty(xxx);
  dao.update(o);
  return null;
}).orElseGet( () -> {
  System.out.println("create new obj");
  dao.save(new obj);
  return null;
});

在本例中，当出现opt时，我更新它的属性并保存到数据库。当它不可用时，我创建一个新的obj并保存到数据库。

注意，在两个lambda中，我必须返回null。

但是当opt存在时，两个lambdas都将被执行。Obj将被更新，一个新的对象将被保存到数据库中。这是因为在第一个lambda中返回null。orElseGet()将继续执行。

为什么要创建一个“隐式未包装的可选”vs只创建一个常规变量或常量? 如果您知道它可以成功地展开，那么为什么要首先创建一个可选选项呢? 举个例子，为什么是这样:

let someString: String! = "this is the string"

将比以下更有用:

let someString: String = "this is the string"

如果“可选项表示一个常量或变量允许‘没有值’”，但是“有时从程序的结构中可以清楚地看出，一个可选项在第一次设置值之后总是有一个值”，那么首先使它成为可选项的意义是什么? 如果你知道一个optional总是有一个值，那它不是可选的吗?

Swift编程语言指南中有如下示例:

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) is being deinitialized") }
}

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

//From Apple's “The Swift Programming Language” guide (https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html)

然后，在给这个人分配公寓时，他们使用感叹号来“打开实例”:

john!.apartment = number73

“展开实例”是什么意思?为什么有必要?它与仅仅做以下事情有什么不同:

john.apartment = number73

我对Swift语言很不熟悉。我只是想把基本的东西记下来。

更新: 我遗漏了一个很大的谜团(答案中没有直接说明——至少在写这篇文章的时候没有)，那就是当你做以下事情的时候:

var john: Person?

这并不意味着“约翰是人的类型，它可能是nil”，因为我最初的想法。我只是误解了《人与人》是完全不同的类型。一旦我明白了，所有其他的?，!疯狂，以及下面这些精彩的回答，让我觉得更有道理。

我在许多网站上读到过，Optional应该只用作返回类型，而不能用于方法参数中。我在努力寻找一个合乎逻辑的原因。例如，我有一个逻辑，它有两个可选参数。因此，我认为这样写我的方法签名是有意义的(解决方案1):

public int calculateSomething(Optional<String> p1, Optional<BigDecimal> p2) {
    // my logic
}

许多网页指定Optional不应该用作方法参数。考虑到这一点，我可以使用下面的方法签名，并添加一个明确的Javadoc注释来指定参数可能为null，希望未来的维护者能够读取Javadoc，因此在使用参数之前总是执行null检查(解决方案2):

public int calculateSomething(String p1, BigDecimal p2) {
    // my logic
}

或者，我可以用四个公共方法替换我的方法，以提供更好的接口，并使p1和p2是可选的(解决方案3):

public int calculateSomething() {
    calculateSomething(null, null);
}

public int calculateSomething(String p1) {
    calculateSomething(p1, null);
}

public int calculateSomething(BigDecimal p2) {
    calculateSomething(null, p2);
}

public int calculateSomething(String p1, BigDecimal p2) {
    // my logic
}

现在，我尝试编写为每种方法调用这段逻辑的类的代码。我首先从另一个返回Optionals的对象检索两个输入参数，然后调用calculatessomething。因此，如果使用解决方案1，调用代码将看起来像这样:

Optional<String> p1 = otherObject.getP1();
Optional<BigInteger> p2 = otherObject.getP2();
int result = myObject.calculateSomething(p1, p2);

如果使用解决方案2，调用代码看起来像这样:

Optional<String> p1 = otherObject.getP1();
Optional<BigInteger> p2 = otherObject.getP2();
int result = myObject.calculateSomething(p1.orElse(null), p2.orElse(null));

如果应用解决方案3，我可以使用上面的代码，也可以使用下面的代码(但它的代码明显更多):

Optional<String> p1 = otherObject.getP1();
Optional<BigInteger> p2 = otherObject.getP2();
int result;
if (p1.isPresent()) {
    if (p2.isPresent()) {
        result = myObject.calculateSomething(p1, p2);
    } else {
        result = myObject.calculateSomething(p1);
    }
} else {
    if (p2.isPresent()) {
        result = myObject.calculateSomething(p2);
    } else {
        result = myObject.calculateSomething();
    }
}

所以我的问题是:为什么使用可选项作为方法参数被认为是不好的做法(参见解决方案1)?对我来说，这看起来是最易读的解决方案，并且对于未来的维护者来说，参数可以是空的/null是最明显的。(我知道Optional的设计者只打算将其用作返回类型，但我找不到在这种情况下不使用它的任何逻辑理由)。