Java8极简手册-04

系列文章链接:

Java8极简手册-01
Java8极简手册-02
Java8极简手册-03
Java8极简手册-04

Maps

如前所述,map并不能直接支持流,他们没有stream()方法,但你可以在map的键、值和实体上创建专门的流,可以通过如下函数map.keySet().stream(), map.values().stream() and map.entrySet().stream().

此外map支持各种新的和有用的方法来执行常见任务。

1
2
3
4
5
6
7
Map<Integer, String> map = new HashMap<>();

for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}

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

上面的代码应该是自我解释的:putIfAbsent阻止我们在null检查时写入额外的代码; forEach 将map的每个值执行操作。

此示例显示如何通过利用函数在地图上计算代码:

1
2
3
4
5
6
7
8
9
10
11
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到给定值:

1
2
3
4
5
map.remove(3, "val3");
map.get(3); // val33

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

另一个比较有用的方法是:

1
map.getOrDefault(42, "not found");  // not found

合并实体在map里面非常方便:

1
2
3
4
5
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

如果不存在键的条目,则合并将键/值放入映射中,或者将调用合并函数以更改现有值。

Date API

Java 8在java.time包下包含一个全新的日期和时间API。 新的Date API与Joda-Time库做比较,但它不一样。 以下示例涵盖了此新API的最重要部分。

Clock

Clock提供对当前日期和时间的访问。 Clocks知道时区,可以使用而不是System.currentTimeMillis()来检索自Unix EPOCH以来的当前时间(以毫秒为单位)。 时间线上的这个瞬时点也由Instant类表示。 Instants可用于创建遗留的java.util.Date对象。

1
2
3
4
5
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();

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

Timezones

时区由ZoneId表示。 可以通过静态工厂方法轻松访问它们。 时区定义了在瞬间和本地日期和时间之间转换的重要偏移。

1
2
3
4
5
6
7
8
9
10
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表示没有时区的时间,例如 晚上10点或17:30:15。 以下示例为上面定义的时区创建两个本地时间。 然后我们比较两次时间并计算两次时间之间的小时和分钟差异。

1
2
3
4
5
6
7
8
9
10
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附带了各种工厂方法,以简化新实例的创建,包括解析时间字符串。

1
2
3
4
5
6
7
8
9
10
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完全类似。 该示例演示了如何通过添加或减去天、月或年来计算新日期。 请记住,每个操作都会返回一个新实例。

1
2
3
4
5
6
7
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

从字符串解析LocalDate就像解析LocalTime一样简单:

1
2
3
4
5
6
7
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表示日期时间。 它将上面部分中的日期和时间组合成一个实例。LocalDateTime是不可变的,其工作方式与LocalTime和LocalDate类似。 我们可以利用从日期时间检索某些字段的方法:

1
2
3
4
5
6
7
8
9
10
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

通过时区的附加信息,它可以转换为瞬间。 可以轻松地将实例转换为java.util.Date类型的旧日期。

1
2
3
4
5
6
Instant instant = sylvester
.atZone(ZoneId.systemDefault())
.toInstant();

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

格式化日期时间就像格式化日期或时间一样。 我们可以使用自定义模式创建格式化程序,而不是使用预定义的格式。

1
2
3
4
5
6
7
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

Java 8中的注释是可重复的。 让我们直接深入了解一个例子来说明这个特性。

首先,我们定义一个包装器注释,它包含实际注释的数组:

1
2
3
4
5
6
7
8
@interface Hints {
Hint[] value();
}

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

Java 8使我们能够通过@Repeatable声明注释来使用相同类型的多个注释。

变体 1: Using the container annotation (old school)

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

变体 2: Using repeatable annotations (new school)

1
2
3
@Hint("hint1")
@Hint("hint2")
class Person {}

使用变体2,java编译器隐式设置引擎盖下的@Hints注释。 这对于通过反射阅读注释信息非常重要。

1
2
3
4
5
6
7
8
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

Although we never declared the @Hints annotation on the Person class, it’s still readable via getAnnotation(Hints.class). However, the more convenient method is getAnnotationsByType which grants direct access to all annotated @Hint annotations.

Furthermore the usage of annotations in Java 8 is expanded to two new targets:

虽然我们从未在Person类上声明@Hints注释,但它仍然可以通过getAnnotation(Hints.class)读取。 但是,更方便的方法是getAnnotationsByType,它允许直接访问所有带注释的@Hint注释。

此外,Java 8中注释的使用扩展到两个新目标:

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