Как выполнить логику на необязательном, если его нет?

С Java 9 или более поздней версии ifPresentOrElse:

Optional<> opt = dao.find();

opt.ifPresentOrElse(obj -> obj.setAvailable(true),
                    () -> logger.error("…"));

Каррирование с использованием vavr или подобного может привести к еще более аккуратному коду, но я еще не пробовал.

Я не думаю, что вы можете сделать это в одном заявлении. Лучше сделать:

if (!obj.isPresent()) {
    logger.fatal(...);   
} else {
    obj.get().setAvailable(true);
}
return obj;

Для Java 8 Spring предлагает ifPresentOrElse из "Служебные методы для работы с необязательными параметрами" для достижения желаемого. Примером может быть:

import static org.springframework.data.util.Optionals.ifPresentOrElse;    

ifPresentOrElse(dao.find(), obj -> obj.setAvailable(true), () -> logger.fatal("Object not available"));

Вам придется разделить это на несколько операторов. Вот один из способов сделать это:

if (!obj.isPresent()) {
  logger.fatal("Object not available");
}

obj.ifPresent(o -> o.setAvailable(true));
return obj;

Другой способ (возможно, слишком сложный) — использовать map:

if (!obj.isPresent()) {
  logger.fatal("Object not available");
}

return obj.map(o -> {o.setAvailable(true); return o;});

Если obj.setAvailable удобно возвращает obj, то вы можете просто использовать второй пример:

if (!obj.isPresent()) {
  logger.fatal("Object not available");
}

return obj.map(o -> o.setAvailable(true));

Прежде всего, ваш dao.find() должен либо вернуть Optional<Obj>, либо вам придется его создать.

e.g.

Optional<Obj> = dao.find();

или вы можете сделать это самостоятельно, например:

Optional<Obj> = Optional.ofNullable(dao.find());

этот вернет Optional<Obj>, если он присутствует, или Optional.empty(), если его нет.

Итак, теперь давайте перейдем к решению,

public Obj getObjectFromDB() {
   return Optional.ofNullable(dao.find()).flatMap(ob -> {
            ob.setAvailable(true);
            return Optional.of(ob);    
        }).orElseGet(() -> {
            logger.fatal("Object not available");
            return null;
        });
    }

Это тот лайнер, который вы ищете :)

Существует есть метод .orElseRun, но он называется .orElseGet.

Основная проблема с вашим псевдокодом заключается в том, что .isPresent не возвращает Optional<>. Но .map возвращает Optional<> с методом orElseRun.

Если вы действительно хотите сделать это в одном выражении, это возможно:

public Optional<Obj> getObjectFromDB() {
    return dao.find()
        .map( obj -> { 
            obj.setAvailable(true);
            return Optional.of(obj); 
         })
        .orElseGet( () -> {
            logger.fatal("Object not available"); 
            return Optional.empty();
    });
}

Но это еще более неуклюже, чем то, что у вас было раньше.

Для тех из вас, кто хочет выполнить побочный эффект, только если необязательное значение отсутствует

то есть эквивалент ifAbsent() или ifNotPresent() здесь является небольшой модификацией уже предоставленных замечательных ответов.

myOptional.ifPresentOrElse(x -> {}, () -> {
  // logic goes here
})

Мне удалось придумать пару решений «одной строки», например:

    obj.map(o -> (Runnable) () -> o.setAvailable(true))
       .orElse(() -> logger.fatal("Object not available"))
       .run();

or

    obj.map(o -> (Consumer<Object>) c -> o.setAvailable(true))
       .orElse(o -> logger.fatal("Object not available"))
       .accept(null);

or

    obj.map(o -> (Supplier<Object>) () -> {
            o.setAvailable(true);
            return null;
    }).orElse(() () -> {
            logger.fatal("Object not available")
            return null;
    }).get();

Выглядит не очень красиво, что-то вроде orElseRun было бы намного лучше, но я думаю, что вариант с Runnable приемлем, если вам действительно нужно однострочное решение.

С Java 8 Optional это можно сделать с помощью:

    Optional<Obj> obj = dao.find();

    obj.map(obj.setAvailable(true)).orElseGet(() -> {
        logger.fatal("Object not available");
        return null;
    });

Title: "How to execute logic on Optional if not present?"

Answer:

Используйте orElseGet() в качестве обходного пути для отсутствующего ifNotPresent(). И поскольку он ожидает, что мы что-то вернем, просто верните null.

Optional.empty().orElseGet(() -> {
    System.out.println("The object is not present");
    return null;
});

//output: The object is not present

or

Optional.ofNullable(null).orElseGet(() -> {
    System.out.println("The object is not present");
    return null;
});

//output: The object is not present

Я также использую его для простой реализации шаблона singleton с отложенной инициализацией.

public class Settings {
    private Settings(){}    
    private static Settings instance;
    public static synchronized Settings getInstance(){
        Optional.ofNullable(instance).orElseGet(() -> instance = new Settings());
        return instance;
    } 
}

Конечно, содержимое getInstance() можно записать в одну строку, напрямую возвращая первый оператор, но я хотел продемонстрировать использование orElseGet() в качестве ifNotPresent().

Вам нужно Optional.isPresent() и orElse(). Ваш фрагмент не будет работать, потому что он ничего не возвращает, если его нет.

ifPresentOrElse также может обрабатывать случаи нулевых указателей. Легкий подход.

   Optional.ofNullable(null)
            .ifPresentOrElse(name -> System.out.println("my name is "+ name),
                    ()->System.out.println("no name or was a null pointer"));

Я предполагаю, что вы не можете изменить метод dao.find(), чтобы он возвращал экземпляр Optional<Obj>, поэтому вам нужно создать соответствующий метод самостоятельно.

Следующий код должен вам помочь. Я создал класс OptionalAction, который предоставляет вам механизм if-else.

public class OptionalTest
{
  public static Optional<DbObject> getObjectFromDb()
  {
    // doa.find()
    DbObject v = find();

    // create appropriate Optional
    Optional<DbObject> object = Optional.ofNullable(v);

    // @formatter:off
    OptionalAction.
    ifPresent(object)
    .then(o -> o.setAvailable(true))
    .elseDo(o -> System.out.println("Fatal! Object not available!"));
    // @formatter:on
    return object;
  }

  public static void main(String[] args)
  {
    Optional<DbObject> object = getObjectFromDb();
    if (object.isPresent())
      System.out.println(object.get());
    else
      System.out.println("There is no object!");
  }

  // find may return null
  public static DbObject find()
  {
    return (Math.random() > 0.5) ? null : new DbObject();
  }

  static class DbObject
  {
    private boolean available = false;

    public boolean isAvailable()
    {
      return available;
    }

    public void setAvailable(boolean available)
    {
      this.available = available;
    }

    @Override
    public String toString()
    {
      return "DbObject [available=" + available + "]";
    }
  }

  static class OptionalAction
  {
    public static <T> IfAction<T> ifPresent(Optional<T> optional)
    {
      return new IfAction<>(optional);
    }

    private static class IfAction<T>
    {
      private final Optional<T> optional;

      public IfAction(Optional<T> optional)
      {
        this.optional = optional;
      }

      public ElseAction<T> then(Consumer<? super T> consumer)
      {
        if (optional.isPresent())
          consumer.accept(optional.get());
        return new ElseAction<>(optional);
      }
    }

    private static class ElseAction<T>
    {
      private final Optional<T> optional;

      public ElseAction(Optional<T> optional)
      {
        this.optional = optional;
      }

      public void elseDo(Consumer<? super T> consumer)
      {
        if (!optional.isPresent())
          consumer.accept(null);
      }
    }
  }
}