Optional<Object> opt = Optional.fromNullable(null);
assertFalse("不应该有", opt.isPresent());
assertEquals("null", opt.or("null"));
opt = Optional.absent();
assertFalse("不应该有", opt.isPresent());
opt = Optional.of("null");
assertEquals("null", opt.get());
Optional.of(null);

int i = -1, j = -32;
assertThrows(IllegalArgumentException.class, () -> checkArgument(i >= 0, "参数是%s，预期是一个正数", i));
assertThrows(IllegalArgumentException.class, () -> checkArgument(i < j, "需要i < j，但是 %s >= %s", i, j));

assertTrue(Objects.equal("a", "a")); // returns true
assertFalse(Objects.equal(null, "a")); // returns false
assertFalse(Objects.equal("a", null)); // returns false
assertTrue(Objects.equal(null, null)); // returns true

public class TestPojo implements Comparable<TestPojo> {
    
    ...
        
    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this)
                .add("desc", desc)
                .add("user", user)
                .add("price", price)
                .add("title", title)
                .add("buyCount", buyCount)
                .add("viewCount", viewCount)
                .add("contentSize", contentSize)
                .add("img", img)
                .add("category", category)
                .add("createdAt", createdAt)
                .add("updatedAt", updatedAt)
                .add("finishedAt", finishedAt)
                .add("isFinished", isFinished)
                .add("isDeleted", isDeleted)
                .add("isHot", isHot)
                .add("isPublish", isPublish)
                .add("isShow", isShow)
                .add("profile", profile)
                .add("lastSectionCount", lastSectionCount)
                .add("pv", pv)
                .add("timeLimitDiscountFirstDay", timeLimitDiscountFirstDay)
                .add("timeLimitDiscount", timeLimitDiscount)
                .add("wechatSignal", wechatSignal)
                .add("wechatImg", wechatImg)
                .add("wechatImgDesc", wechatImgDesc)
                .add("url", url)
                .add("section", section)
                .add("tags", tags)
                .toString();
    }
    
    @Override
    public int compareTo(TestPojo that) {
        return ComparisonChain.start()
            .compare(this.buyCount, that.buyCount)
            .compare(this.contentSize, that.contentSize)
            .result();
    }
}

String[] array = {"1", "2", null, "3", "12", null, "14"};
assertThrows(NullPointerException.class, () -> Arrays.sort(array, Ordering.natural()));
logger.info(Arrays.toString(array)); // [1, 2, null, 3, 12, null, 14]

Arrays.sort(array, Ordering.natural().nullsFirst());
assertArrayEquals(new String[]{null, null, "1", "12", "14", "2", "3"}, array);
logger.info(Arrays.toString(array)); // [null, null, 1, 12, 14, 2, 3]

Arrays.sort(array, Ordering.natural().nullsLast());
assertArrayEquals(new String[]{"1", "12", "14", "2", "3", null, null}, array);
logger.info(Arrays.toString(array)); // [1, 12, 14, 2, 3, null, null]

Arrays.sort(array, Ordering.natural().reverse().nullsLast());
assertArrayEquals(new String[]{"3", "2", "14", "12", "1", null, null}, array);
logger.info(Arrays.toString(array)); // [3, 2, 14, 12, 1, null, null]

Arrays.sort(array, Ordering.natural().nullsLast().reverse());
assertArrayEquals(new String[]{null, null, "3", "2", "14", "12", "1"}, array);
logger.info(Arrays.toString(array)); // [null, null, 3, 2, 14, 12, 1]

Arrays.sort(array, Ordering.natural().onResultOf(new Function<String, Integer>() {
    @Nullable
    @Override
    public Integer apply(@Nullable String input) {
        return Integer.valueOf(Optional.fromNullable(input).or("-1"));
    }
}));
assertArrayEquals(new String[]{null, null, "1", "2", "3", "12", "14"}, array);
logger.info(Arrays.toString(array)); // [null, null, 1, 2, 3, 12, 14]

ImmutableSet.copyOf(set);
ImmutableSet.of("a", "b", "c");
ImmutableMap.of("a", 1, "b", 2);
public static final ImmutableSet<Color> GOOGLE_COLORS =
   ImmutableSet.<Color>builder()
       .addAll(WEBSAFE_COLORS)
       .add(new Color(0, 191, 255))
       .build();

Map<String, Integer> counts = new HashMap<String, Integer>();
for (String word : words) {
  Integer count = counts.get(word);
  if (count == null) {
    counts.put(word, 1);
  } else {
    counts.put(word, count + 1);
  }
}

List<String> list = Lists.newArrayList("hello", "guava", "hello", "world");
HashMultiset<String> multiset = HashMultiset.create();
multiset.addAll(list);
assertEquals(2, multiset.count("hello"));
assertEquals(1, multiset.count("guava"));
assertEquals(0, multiset.count("guave"));

List<String> list = Lists.newArrayList("hello", "guava", "hello", "world");
HashMultiset<String> multiset = HashMultiset.create();
multiset.addAll(list);
assertEquals(2, multiset.count("hello"));
assertEquals(1, multiset.count("guava"));
assertEquals(0, multiset.count("guave"));

Multimap<Integer, Integer> listMultimap = MultimapBuilder.treeKeys().arrayListValues().build();
Multimap<Integer, Integer> setMultimap = MultimapBuilder.hashKeys().hashSetValues().build();

listMultimap.put(1, 2);
listMultimap.put(1, 2);
listMultimap.put(1, 3);
listMultimap.put(1, 4);
listMultimap.put(2, 3);
listMultimap.put(3, 3);
listMultimap.put(4, 3);
listMultimap.put(5, 3);

setMultimap.put(1, 2);
setMultimap.put(1, 2);
setMultimap.put(1, 3);
setMultimap.put(1, 4);
setMultimap.put(2, 3);
setMultimap.put(3, 3);
setMultimap.put(4, 3);
setMultimap.put(5, 3);

assertEquals(4, listMultimap.get(1).size());
assertEquals(0, listMultimap.get(6).size());
assertNull(listMultimap.asMap().get(6));

assertEquals(3, setMultimap.get(1).size());
// 对值视图集合进行的修改最终都会反映到底层的Multimap
setMultimap.get(1).remove(2);
assertEquals(2, setMultimap.get(1).size());

assertTrue(listMultimap.containsKey(1));
assertFalse(listMultimap.containsKey(6));

Map<String, Integer> nameToId = Maps.newHashMap();
Map<Integer, String> idToName = Maps.newHashMap();

nameToId.put("Bob", 42);
idToName.put(42, "Bob");
// what happens if "Bob" or 42 are already present?
// weird bugs can arise if we forget to keep these in sync...

Table<String, String, Integer> tables = HashBasedTable.create();
tables.put("a", "javase", 80);
tables.put("b", "javaee", 90);
tables.put("c", "javame", 100);
tables.put("c", "javaee", 80);
tables.put("d", "guava", 70);

// 所有学生
Set<String> students = tables.rowKeySet();
assertEquals(Sets.newHashSet("a", "b", "c", "d"), students);

// 找到对应学生和科目的成绩
assertEquals(100, tables.get("c", "javame").intValue());
assertEquals(80, tables.get("c", "javaee").intValue());

// 所有课程
Set<String> courses = tables.columnKeySet();
assertEquals(Sets.newHashSet("javase", "javaee", "javame", "guava"), courses);

// 所有分数
Collection<Integer> scores = tables.values();
assertArrayEquals(Lists.newArrayList(80, 90, 100, 80, 70).toArray(new Integer[]{}), scores.toArray(new Integer[]{}));

RangeSet<Integer> rangeSet = TreeRangeSet.create();
rangeSet.add(Range.closed(1, 10)); // {[1,10]}
rangeSet.add(Range.closedOpen(11, 15));//不相连区间:{[1,10], [11,15)}
rangeSet.add(Range.closedOpen(15, 20)); //相连区间; {[1,10], [11,20)}
rangeSet.add(Range.openClosed(0, 0)); //空区间; {[1,10], [11,20)}
rangeSet.remove(Range.open(5, 10)); //分割[1, 10]; {[1,5], [10,10], [11,20)}

RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
rangeMap.put(Range.closed(1, 10), "foo"); //{[1,10] => "foo"}
rangeMap.put(Range.open(3, 6), "bar"); //{[1,3] => "foo", (3,6) => "bar", [6,10] => "foo"}
rangeMap.put(Range.open(10, 20), "foo"); //{[1,3] => "foo", (3,6) => "bar", [6,10] => "foo", (10,20) => "foo"}
rangeMap.remove(Range.closed(5, 11)); //{[1,3] => "foo", (3,5) => "bar", (11,20) => "foo"}

CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "CONSTANT_NAME"));