According to p.1 "API changes require discussion, use cases, etc. Code comes later.", I'm going to start discussion about benefits of proposed changes. 

Now com.google.common.cache.CacheBuilder contains such methods as
`refreshAfterWrite(long duration, TimeUnit unit)`
`expireAfterWrite(long duration, TimeUnit unit)`
`expireAfterAccess(long duration, TimeUnit unit)`
Parameters of methods listed below are used to define durations in time.
However, in Java 8 new class,  [java.time.Duration](https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html), was presented. It can be used to save info about time durations in exactly one object. That is easier and more transparent in some real-world scenarios. 

The idea is to add overloaded methods:
`refreshAfterWrite(Duration duration)
expireAfterWrite(Duration duration)
expireAfterAccess(Duration duration)`

Proposed changes provide possibilities to simplify code:
`expireAfterWrite(Duration.ofHours(3))
// instead of
expireAfterWrite(3, TimeUnit.HOURS)
`
It makes easier to declare constant durations too:

`public static final Duration EXPIRES_IN = Duration.ofHours(1);
// some code after statement
expireAfterWrite(EXPIRES_IN)
`
instead of
`public static final long DURATION_LENGTH = 1;
 public static final TimeUnit DURATION_TIME_UNIT = TimeUnit.HOURS;
 // some code after statement
 expireAfterWrite(DURATION_LENGTH, DURATION_TIME_UNIT)
`

Also, it allows to execute some arifmetic operations like addition or subtraction, that can simplify program logic if multiple (and dependant) durations in different methods and/or in different caches are used. Just something like this (simplified synthetic example):
`
Duration expiresAfterAccessIn = Duration.ofMinutes(30);
CacheBuilder.newBuilder()
                    .expireAfterAccess(expiresAfterAccessIn)
                    .expireAfterWrite(expiresAfterAccessIn.plusHours(1))
                    .build();
`

This improvements do not lead to changing min java sdk version and do not break existing API.
public class CacheBuilderTest extends TestCase {
  public void testNewBuilder() {
    CacheLoader<Object, Integer> loader = constantLoader(1);
    LoadingCache<String, Integer> cache =
        CacheBuilder.newBuilder().removalListener(countingRemovalListener()).build(loader);
    assertEquals(Integer.valueOf(1), cache.getUnchecked("one"));
    assertEquals(1, cache.size());
  }
  public void testInitialCapacity_negative() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
    try {
      builder.initialCapacity(-1);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }
  public void testInitialCapacity_setTwice() {
    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().initialCapacity(16);
    try {
      
      builder.initialCapacity(16);