JAVA8 教程

本文是对Benjamin的JAVA8 教程的翻译，原文地址如下：

原文地址

本文会逐步介绍JAVA8的新特性，通过简短的代码实例，你会了解如何使用接口方法（interface methods），lambda表达式（lambda expressions），方法引用（method references），可重复的注解（repeatable annotations）。文章结尾部分会介绍JAVA8中API更新信息，比如：streams, functional interfaces, map extensions ,the new Date API.

Default Methods for Interfaces###

在JAVA8中可以通过default关键字在接口中添加一个非抽象方法（即：扩展方法），例子如下：

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

接口Formula中除了抽象方法calculate外还定义了一个default方法sqrt。实现类只需要实现抽象方法calculate，default方法可以在接口外直接调用。

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

上面的Demo中通过匿名对象的形式实现了formula接口，一共花费了6行代码实现了平方运算：sqrt(a * 100)，代码比较冗长。在下一节中，我们会采用一个更好的方法来实现这种只有一个抽象方法的接口。

Lambda expressions###

在JAVA8之前通常采用如下方法对一个字符串列表进行排序：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

静态方法Collections.sort接收一个list和一个comparator类来执行排序操作。你通常需要创建一个匿名的comparators对象，并把这个对象传递给Collections.sort方法。

通过java8中的lambda表达式，可以采用一个更简短的方式解决上面的问题。

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

上面的代码更简短可读性更好，我们可以继续精简上面的代码：

Collections.sort(names, (String a, String b) -> b.compareTo(a));

对于方法体只有一行的代码，我们可以省略{}和return关键字。我们还能继续精简上述代码：

Collections.sort(names, (a, b) -> b.compareTo(a));

JAVA编译器能够根据上下文推测出参数的类型，因此我们也可以省略参数类型信息

下面我们会更深入了解如何使用lambda表达式。

Functional Interfaces（函数式接口）###

Lambda表达式是如何融合到java类型系统中的？

每个Lambda表达式都与特定的类型相关联，这些类型信息则由接口指定。同时函数式接口必须包含一个抽象方法声明，从而可以将Lambda表达式和函数式接口的抽象方法匹配起来。

可以使用任意只包含一个抽象方法的接口做为Lambda表达式，为保证接口满足Lambda表达式的需求，应该在接口上添加@FunctionalInterface注解，编译器在运行的时候会监控带有@FunctionalInterface注解的接口，如果在这个接口中包含多个抽象方法，会抛出编译异常。例如：

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

请注意，注释掉@FunctionalInterface上述代码也是有效的。

Method and Constructor References###

通过静态方法可以进一步简化上面例子中的代码：

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

JAVA8允许通过::关键字传递方法或者构造函数的引用，上面的例子展示了如何引用静态方法，同样可以引用对象方法：

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

再看下如何在构造方法上使用::关键字，我们首先定义一个有多个构造函数的bean。

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

然后我们定义一个可以创建person的person factory接口

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

通过构造函数引用实现工厂接口：

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

上面的例子中通过Person::new创建一个Person类构造函数的引用，Java编译器会根据PersonFactory.create方法的签名自动选择合适的构造函数。

Lambda Scopes###

Lambda表达式访问变量的范围与匿名内部类相同，可以访问本地final变量以及静态实例变量。

Accessing local variables

我们可以访问lambda表达式的外部的局部final变量

final int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3

但与匿名对象不同，变量num不必声明为final。下面的代码也是有效的

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);

stringConverter.convert(2);     // 3

但是如果要进行编译的话，num必须是隐式的final类型，下面的这段代码无法编译

int num = 1;
Converter<Integer, String> stringConverter =
        (from) -> String.valueOf(from + num);
num = 3;

在lambda表达式中修改num的值也是被禁止的。

Accessing fields and static variables （访问成员变量和静态变量）###

与本地变量不同，在lambda表达式中可以访问（读写）成员变量和静态变量，与匿名内部类的特性类似。

class Lambda4 {
    static int outerStaticNum;
    int outerNum;

    void testScopes() {
        Converter<Integer, String> stringConverter1 = (from) -> {
            outerNum = 23;
            return String.valueOf(from);
        };

        Converter<Integer, String> stringConverter2 = (from) -> {
            outerStaticNum = 72;
            return String.valueOf(from);
        };
    }
}

Accessing Default Interface Methods(访问默认接口方法)###

在第一个Formula例子中，接口Formula定义了一个默认接口方法：sqrt，这个方法能够被每个Formula接口的实例访问（包括匿名实例），但是lambda表达式中不能够访问默认接口方法。下面的例子无法编译通过：

Formula formula = (a) -> sqrt( a * 100);

Built-in Functional Interfaces (内置函数式接口)###

JDK 1.8 API中包含许多内置的函数式接口，其中一些在老版本的JDK中就比较知名，比如：Comparator，Runnable。JDK中在这些接口上添加了@FunctionalInterface注解，使得这些接口能够支持lambda表达式。Java 8 API也新增了一些新的函数式接口，这些新增的接口部分已经在google的guava包中被人所了解。

Predicates(断言)

Predicates是包含一个参数返回值为boolean型的函数，为了满足复杂的逻辑条件(or and negate)Predicates接口包含各种默认方法。

Predicate<String> predicate = (s) -> s.length() > 0;

predicate.test("foo");              // true
predicate.negate().test("foo");     // false

Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;

Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();

Functions

Functions接口接收一个参数并生成一个结果，可以使用Functions接口的默认方法（compose, andThen）将多个functions串联起来。

注：compose, andThen的区别，compose方法自身先执行，再把执行结果传递给调用者执行。andThen先执行前一步的调用者，获取前一步执行结果后再执行。详情请参考Java 8: Composing functions using compose and andThen一文

Function<Integer, Integer> times2 = e -> e * 2;

Function<Integer, Integer> squared = e -> e * e;  


times2.compose(squared).apply(4);  
// Returns 32

times2.andThen(squared).apply(4);  
// Returns 64

Suppliers

Suppliers接口不接收任何参数，能生成给定泛型类型的结果

Supplier<Person> personSupplier = Person::new;
personSupplier.get();   // new Person

Consumers

Consumers接口表示在单个输入参数上要执行的操作。

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));

Comparators

Comparators接口在老版本的java中已经存在，JAVA8中在该接口上添加一些新的默认方法

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);

Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");

comparator.compare(p1, p2);             // > 0
comparator.reversed().compare(p1, p2);  // < 0

Optionals

Optionals不是一个函数式接口，而是一个用来防止出现NullPointerException异常的很好工具。Optionals类在下一节中是一个很重要的概念，我们先快速预览下Optionals如何工作。

Optional是一个存储的值可能为null或者非null的简单容器，在JAVA8中当一个方法的返回值可能为null的时候，可以用返回Optional代替这个null。

Optional<String> optional = Optional.of("bam");

optional.isPresent();           // true
optional.get();                 // "bam"
optional.orElse("fallback");    // "bam"

optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"

Streams

java.util.Stream表示可以执行一个或多个操作的序列元素，stream的操作可以分为两种类型：中间操作或最终操作。中间操作的返回值还是一个stream，最终操作的返回值是一个确定的类型。可以通过链式调用可以将多个中间操作串联起来。stream由java.util.Collection生成，比如like lists sets （map不能生成stream）都能生成一个stream，stream上的操作既可以串行执行也可以是并行执行。

我们先看下stream的串行执行，下面的例子中我们首先构建一个string类型的list：

List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");

在JAVA8中Collections包中增加了一些新的特性，可以通过Collection.stream()或者Collection.parallelStream()方法轻松起创建一个stream。下面的章节会介绍最常用的stream操作。

Filter

Filter通过断言来对stream中所有的元素进行判断，由于filter是一个中间操作，因此我们可以在filter后面再调用forEach操作，ForEach操作接收一个consumer接口作为参数，这个consumer会在所有通过filter的元素上执行。ForEach是一个最终操作，返回值类型是void，因此我们不能在ForEach后面再调用其他操作。

stringCollection
    .stream()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

// "aaa2", "aaa1"

Sorted

Sorted是一个中间操作，sorted操作接收Comparator接口作为参数，返回一个有序的stream。如果传递一个空函数给sorted，则不进行排序操作。

stringCollection
    .stream()
    .sorted()
    .filter((s) -> s.startsWith("a"))
    .forEach(System.out::println);

// "aaa1", "aaa2"

Map

map是一个中间操作，通过给定的转换方法map能将stream中的每个元素映射为另外一种对象，下面的例子中将每个string转换为upper-cased string。map也支持不同类型的映射，具体映射的目标类型取决于映射方法的返回值类型。

stringCollection
    .stream()
    .map(String::toUpperCase)
    .sorted((a, b) -> b.compareTo(a))
    .forEach(System.out::println);

// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

Match

matching是一个最终操作，返回值类型为boolean型，可以用来确定某种断言是否与stream匹配。

boolean anyStartsWithA =
    stringCollection
        .stream()
        .anyMatch((s) -> s.startsWith("a"));

System.out.println(anyStartsWithA);      // true

boolean allStartsWithA =
    stringCollection
        .stream()
        .allMatch((s) -> s.startsWith("a"));

System.out.println(allStartsWithA);      // false

boolean noneStartsWithZ =
    stringCollection
        .stream()
        .noneMatch((s) -> s.startsWith("z"));

System.out.println(noneStartsWithZ);      // true

Count

Count是一个最终操作，返回stream中元素的个数，返回值类型为long。

long startsWithB =
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();

System.out.println(startsWithB);    // 3

Reduce

Reduce是一个最终操作，通过给定的方法在stream上执行reduce操作，返回值为使用Optional接口包装的reduce值。

Optional<String> reduced =
    stringCollection
        .stream()
        .sorted()
        .reduce((s1, s2) -> s1 + "#" + s2);

reduced.ifPresent(System.out::println);
// "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"

Parallel Streams

Parallel Streams能在多个线程上并发地执行，下面的例子中通过简单的使用parallel streams就能大幅度地提高系统性能。

首先我们创建一个很大的元素唯一的list

int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

我们开始测试在这个stream上执行排序所需的时间

Sequential Sort

long t0 = System.nanoTime();

long count = values.stream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis));

// sequential sort took: 899 ms

Parallel Sort

long t0 = System.nanoTime();

long count = values.parallelStream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis));

// parallel sort took: 472 ms

上面的两段代码几乎相同，但是parallel sort的速度几乎比sequential Sort速度快50%。

Map

前面的章节中已经提到map不支持stream，但是maps现在新增了一些有用的方法：

Map<Integer, String> map = new HashMap<>();

for (int i = 0; i < 10; i++) {
    map.putIfAbsent(i, "val" + i); //如果key未分配值或者值为Null，则设置key的值并返回null,否则返回当前值

}

map.forEach((id, val) -> System.out.println(val));

map中新增的putIfAbsent方法可以减少null判断，forEach方法通过consumer接口在map中每个元素上执行操作。

下面的这个例子展示了在map中如何使用functions接口

map.computeIfPresent(3, (num, val) -> val + num);
map.get(3);             // val33

map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9);     // false

map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23);    // true

map.computeIfAbsent(3, num -> "bam");
map.get(3);             // val33

下面的例子展示了map如何删除value不为空的key的操作。

map.remove(3, "val3");
map.get(3);             // val33

map.remove(3, "val33");
map.get(3);             // null
Another helpful method:

map.getOrDefault(42, "not found");  // not found
Merging entries of a map is quite easy:

map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9

map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9concat

merge方法在key不存在时，可以向map中添加key/value，当key存在时，可以对这个key对应的value执行merge操作。

Date API###

JAVA8的java.time包中包含了一个全新的日期和时间API。尽管新的日期API与Joda-Time不完全相同，但是它的功能完全能和Joda-Time库相媲美，下面的例子包含了新的日期API中绝大部分重要内容。

Clock

Clock抽象类提供了能够访问当前时区的日期和时间的方法，Clock的值与时区相关可以被用来替换System.currentTimeMillis()来获取当前时区的毫秒值。Instant类也能表示这种在时间线上的瞬时点，Instant可以用来生成老版本中的java.util.Date对象。

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();

Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // legacy java.util.Date

Timezones

Timezones由ZoneId表示，可以通过静态工厂方法获取，Timezones定义了instants(瞬间)与当地的日期和时间之间进行转换时十分有用的偏移量

System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids

ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());

// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]

LocalTime

LocalTime表示与时区无关的时间，例如10pm或者17:30:15，下面的例子根据上面定义的timezones创建了两个LocalTime，然后比较并计算这两个值

LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);

System.out.println(now1.isBefore(now2));  // false

long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);

System.out.println(hoursBetween);       // -3
System.out.println(minutesBetween);     // -239

LocalTime带有各种工厂方法来简化创建新的实例，还可以解析时间字符串创建实例。

LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late);       // 23:59:59

DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedTime(FormatStyle.SHORT)
        .withLocale(Locale.GERMAN);

LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime);   // 13:37

LocalDate

LocalDate表示不同的日期，例如 2014年-03-11。它是不可变的，工作原理完全模拟LocalTime。下面的例子展示了通过加减法获取一个新的日期。需要注意的是每个操作都会返回一个新的实例。

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);

LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek);    // FRIDAY

将一个String转换为LocalDate十分简单：

DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedDate(FormatStyle.MEDIUM)
        .withLocale(Locale.GERMAN);

LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas);   // 2014-12-24

LocalDateTime

LocalDateTime表示一个日期时间，它将上面章节介绍的date和time整合成一个实例。LocalDateTime是不可变的，使用起来类似 LocalTime和LocalDate，我们可以利用某些方法从日期时间检索某些字段。

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);

DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // WEDNESDAY

Month month = sylvester.getMonth();
System.out.println(month);          // DECEMBER

long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439
With the additional information of a timezone it can be converted to an instant. Instants can easily be converted to legacy dates of type java.util.Date.

Instant instant = sylvester
        .atZone(ZoneId.systemDefault())
        .toInstant();

Date legacyDate = Date.from(instant);
System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014

格式化date-times与格式化dates或者times类似，我们可以自定义pattern来格式化日期而不仅仅是使用预定义的格式。

DateTimeFormatter formatter =
    DateTimeFormatter
        .ofPattern("MMM dd, yyyy - HH:mm");

LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string);     // Nov 03, 2014 - 07:13

与java.text.NumberFormat相比DateTimeFormatter是不可变的且线程安全的，

更多时间格式化相关的知识可以阅读此文

Annotations###

Annotations在JAVA8中是可以重复的，我们通过例子展示这个特性：

我们定义一个包装annotation的annotation，这个annotation包含一个真实的annotation数组。

@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}

通过声明注解@Repeatable，JAVA8允许我们使用多个相同类型的annotations

方式1: 使用容器注解 annotation (老的方式)

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}

方式2: 使用可重复annotations (新的方式)

@Hint("hint1")
@Hint("hint2")
class Person {}

在方式2中，java编译器隐私地在创建了一个@Hints注解，这在通过反射获取annotation信息时十分有用。

Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint);                   // null

Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length);  // 2

Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length);          // 2

尽管我们没有在Person这个类上声明@Hints注解，但是仍然能过通过getAnnotation(Hints.class)方法获取到，通过getAnnotationsByType便利方法能够直接访问@Hint类型的注解。

此外JAVA8中的annotations新增了两个目标：

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}

总结###

如果你想了解更多JAVA8中新的类和特性，请阅读文章，它可以帮助你了解更多JAVA8中新的类和和特性，比如：Arrays.parallelSort, StampedLock，CompletableFuture

本文的所有源码都保存在github上，你可以fork它或者通过titter给我以反馈。

翻译by：weiye

有问题可以通过微博联系。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,547评论 6赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,399评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,428评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,599评论 1赞 274
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,612评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,577评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,941评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,603评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,852评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,605评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,693评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,375评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,955评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,936评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,172评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 43,970评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,414评论 2赞 342

推荐阅读更多精彩内容

  • Java8
    Java8 in action 没有共享的可变数据，将方法和函数即代码传递给其他方法的能力就是我们平常所说的函数式...
    铁牛很铁阅读 1,208评论 1赞 2
  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,585评论 18赞 139
  • 【译】java8之stream
    Streams 原文链接： Streams 原文作者： shekhargulati 译者： leege100 状态...
    忽来阅读 5,511评论 3赞 32
  • java8 lambda
    lambda表达式（又被成为“闭包”或“匿名方法”）方法引用和构造方法引用扩展的目标类型和类型推导接口中的默认方法...
    183207efd207阅读 1,464评论 0赞 5
  • 7岁小男孩偷拿妈妈面膜，在课上淡定地敷，你怎么看？
    微博上一位老师发了一张图，引发网友热议。 这位老师在自己的辅导班里遇到了一个敷面膜的男生。 就是这个淡定地看书的小...
    奇妈育儿阅读 310评论 1赞 1