Java8 新特性学习
摘自：https://blog.csdn.net/shuaicihai/article/details/72615495
Lambda 表达式
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：
- 左侧：指定了 Lambda 表达式需要的所有参数
- 右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。
Lambda 表达式语法
语法格式一：无参，无返回值，Lambda 体只需一条语句
Runnable runnable = () -> System.out.println("hello Lambda");
语法格式二：Lambda 需要一个参数
Consumer<String> con = (t) -> System.out.println(t);
语法格式三：Lambda 只需要一个参数时，参数的小括号可以省略
Consumer<String> con = t -> System.out.println(t);
语法格式四：Lambda 需要两个参数，并且有返回值
Comparator<Integer> comparator = (x,y) -> {
System.out.println("相加结果是:"+(x+y));
return Integer.compare(x,y);
};
语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略
Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
语法格式六：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
类型推断
上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。
/**
* Lambda表达式基础语法,Java8中引入新的操作符"->"
* Lambda表达式分为左右两部分:
* 左:Lambda表达式的参数列表
* 右:Lambda表达式中所需执行的功能,即Lambda体
*/
public class LambdaDemo { @Test
public void test1(){
Runnable r = new Runnable() { @Override
public void run() {
System.out.println("hello world");
}
};
r.run();
System.out.println("------------"); //Lambda表达式
Runnable runnable = () -> System.out.println("hello Lambda");
runnable.run();
} @Test
public void test2(){
Consumer<String> consumer = new Consumer<String>() { @Override
public void accept(String t) {
System.out.println(t);
}
};
consumer.accept("hello consumer !");
System.out.println("---------------"); //Lambda表达式
// Consumer<String> con = (t) -> System.out.println(t);
Consumer<String> con = t -> System.out.println(t);
con.accept("hello Lambda !");
} @Test
public void test3(){
Comparator<Integer> comparator = (x,y) -> {
System.out.println("相加结果是:"+(x+y));
return Integer.compare(x,y);
}; int compare = comparator.compare(1, 2);
System.out.println(compare);
} @Test
public void test4(){
Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y); int compare = comparator.compare(1, 2);
System.out.println(compare);
} @Test
public void test5(){
show(new HashMap<>());
} public void show(Map<String,Integer> map){ }
}
函数式接口
- 只包含一个抽象方法的接口，称为函数式接口。
- 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
- 我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。
Java 内置四大核心函数式接口
/**
* 函数式接口
*/
public class TestFunction { //Consumer<T>消费型接口
@Test
public void test1(){
cost(8888, (m) -> System.out.println("共消费:" + m + "元"));
} public void cost(double money,Consumer<Double> con){
con.accept(money);
} //Supplier<T> 供给型接口
@Test
public void test2(){
List<Integer> list = getNumList(8, () -> (int)(Math.random() * 100));
for (Integer integer : list) {
System.out.println(integer);
}
} //产生指定数量的整数,放入集合中
public List<Integer> getNumList(int num,Supplier<Integer> sup){
List<Integer> list = new ArrayList<Integer>(); for (int i = 0; i < num; i++) {
Integer n = sup.get();
list.add(n);
} return list;
} //Function<T,R> 函数型接口
@Test
public void test3(){
String string = strHandler(" 函数型接口测试 ", (str) -> str.trim().substring(0, 5));
System.out.println(string);
} //用于处理字符串
public String strHandler(String str,Function<String, String> fun){
return fun.apply(str);
} //Predicate<T> 断言型接口
@Test
public void test4(){
List<String> list = Arrays.asList("hello","Lambda","ok");
List<String> strList = filterStr(list, (s) -> s.length() > 3);
for (String string : strList) {
System.out.println(string);
}
} //将满足条件的字符串,放入集合中
public List<String> filterStr(List<String> list, Predicate<String> pre){
List<String> strList = new ArrayList<>(); for (String str : list) {
if (pre.test(str)) {
strList.add(str);
}
}
return strList;
}
}
其他接口
方法引用与构造器引用
方法引用
当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。
如下三种主要使用情况：
- 对象::实例方法
- 类::静态方法
- 类::实例方法
使用注意事项:
* 1.Lambda 体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的函数列表和返回值类型保持一致。
* 2.若Lambda 参数列表中第一个参数是实例方法调用者,第二个参数是实例方法的参数 可以使用 ClassName :: method
构造器引用
与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！
格式： ClassName::new
数组引用
格式： type[] :: new
/**
* 方法引用:若Lambda 体中的内容有方法已经实现了,我们可以使用"方法引用"
*/
public class TestMethodRef { @Test
public void test1(){
Consumer<String> con = (x) -> System.out.println(x);
con.accept("shuai"); //方法引用,对象::实例方法名
Consumer<String> consumer = System.out::println;
consumer.accept("test");
} @Test
public void test2(){
Person person = new Person();
Supplier<String> supplier = () -> person.getName();
String str = supplier.get();
System.err.println(str); //方法引用,对象::实例方法名
Supplier<Integer> sup = person::getAge;
Integer age = sup.get();
System.out.println(age);
} //类::静态方法名
@Test
public void test3(){
Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
//使用前提,compare的参数和返回值与Comparator一致
Comparator<Integer> comparator = Integer :: compare;
} //类::实例方法名
@Test
public void test4(){
BiPredicate<String, String> bp = (x,y) -> x.equals(y);
//使用条件:第一个参数是实例方法调用者,第二个参数是实例方法的参数
BiPredicate<String, String> biPredicate = String :: equals;
} //构造器引用
@Test
public void test5(){
Supplier<Person> sup = () -> new Person(); //构造器引用方式
Supplier<Person> supplier = Person :: new;
Person person = supplier.get();
System.out.println(person);
} //构造器引用
@Test
public void test6(){
Function<Integer, Person> fun = (x) -> new Person(x); Function<Integer, Person> function = Person :: new;
Person person = function.apply(2);
System.out.println(person);
System.out.println("--------------------"); BiFunction<String, Integer, Person> biFunction = Person :: new;
Person person2 = biFunction.apply("张三", 23);
System.out.println(person2);
} //数组引用
@Test
public void test7(){
Function<Integer, String[]> fun = (x) -> new String[x];
String[] strs = fun.apply(8);
System.out.println(strs.length); Function<Integer, String[]> function = String[] :: new;
String[] strArray = function.apply(6);
System.out.println(strArray.length);
}
}
Stream API
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。
Stream
是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。
“集合讲的是数据，流讲的是计算！”
1. Stream 自己不会存储元素。
2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream 的操作三个步骤
- 创建 Stream
一个数据源（如：集合、数组），获取一个流 - 中间操作
一个中间操作链，对数据源的数据进行处理 - 终止操作(终端操作)
一个终止操作，执行中间操作链，并产生结果
创建 Stream
Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
- default Stream stream() : 返回一个顺序流
- default Stream parallelStream() : 返回一个并行流
Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
- static Stream stream(T[] array): 返回一个流
可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。
- public static Stream of(T… values) : 返回一个流
可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。
- 迭代
public static Stream iterate(final T seed, final UnaryOperator f)
- 生成
public static Stream generate(Supplier s) :
//创建Stream
@Test
public void test1(){
//1.可以通过Collection系列集合提供的stream() 或parallelStream()
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //2.通过Arrays中静态方法 stream() 获取数组流
Person[] persons = new Person[10];
Stream<Person> stream2 = Arrays.stream(persons); //3.通过Stream类中的静态方法 of()
Stream<String> stream3 = Stream.of("a","b","c"); //4.创建无限流
//迭代
Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
stream4.limit(8).forEach(System.out :: println); //生成
Stream.generate(() -> Math.random()).limit(6)
.forEach(System.out :: println);
}
Stream 的中间操作
多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。
筛选与切片
映射
排序
/**
* Stream API的中间操作
*/
public class TestSteamAPI2 { List<Person> persons = Arrays.asList(
new Person(2, "钱四", 24),
new Person(1, "张三", 33),
new Person(2, "李四", 24),
new Person(3, "王五", 65),
new Person(4, "赵六", 26),
new Person(4, "赵六", 26),
new Person(5, "陈七", 27)
); //内部迭代，由Stream API完成
@Test
public void test1(){
//中间操作,不会执行任何操作
Stream<Person> stream = persons.stream()
.filter((e) -> {
System.out.println("Stream的中间操作");
return e.getAge() > 25;
});
//终止操作，一次性执行全部内容，即"惰性求值"
stream.forEach(System.out :: println);
} //外部迭代
@Test
public void test2(){
Iterator<Person> iterator = persons.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
} //limit，截断
@Test
public void test3(){
persons.stream()
.filter((e) -> {
System.out.println("迭代操作"); //短路
return e.getAge() > 24;
})
.limit(2)
.forEach(System.out :: println);
} //跳过skip,distinct去重(要重写equals和hashcode)
@Test
public void test4(){
persons.stream()
.filter((e) -> e.getAge() > 23)
.skip(2)
.distinct()
.forEach(System.out :: println);
} //映射
@Test
public void test5(){
List<String> list = Arrays.asList("a","bb","c","d","e"); list.stream().map((str) -> str.toUpperCase())
.forEach(System.out :: println);
System.out.println("---------------"); persons.stream().map((Person :: getName)).forEach(System.out :: println);
System.out.println("---------------"); Stream<Stream<Character>> stream = list.stream()
.map(TestSteamAPI2 :: filterCharacter); stream.forEach((s) -> {
s.forEach(System.out :: println);
});
System.out.println("-----------------"); //flatMap
Stream<Character> stream2 = list.stream()
.flatMap(TestSteamAPI2 :: filterCharacter);
stream2.forEach(System.out :: println);
} //处理字符串
public static Stream<Character> filterCharacter(String str){
List<Character> list = new ArrayList<>(); for (Character character : str.toCharArray()) {
list.add(character);
}
return list.stream();
} //排序
@Test
public void test6(){
List<String> list = Arrays.asList("bb","c","aa","ee","ddd"); list.stream()
.sorted() //自然排序
.forEach(System.out :: println);
System.out.println("------------"); persons.stream()
.sorted((p1,p2) -> {
if (p1.getAge() == p2.getAge()) {
return p1.getName().compareTo(p2.getName());
} else {
return p1.getAge() - p2.getAge();
}
}).forEach(System.out :: println); } }
Stream 的终止操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。
查找与匹配
归约
map 和 reduce 的连接通常称为 map-reduce 模式。
收集
Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例。
/**
* Stream API的终止操作
*/
public class TestSteamAPI3 { List<Person> persons = Arrays.asList(
new Person(2, "钱四", 24,Status.YOUNG),
new Person(1, "张三", 23,Status.YOUNG),
new Person(2, "李四", 24,Status.YOUNG),
new Person(3, "王五", 65,Status.OLD),
new Person(4, "赵六", 26,Status.MIDDLE),
new Person(4, "赵六", 56,Status.OLD),
new Person(5, "陈七", 27,Status.MIDDLE)
); //查找与匹配
@Test
public void test1(){
boolean b = persons.stream()
.allMatch((e) -> e.getStatus().equals(Status.YOUNG));
System.out.println(b); boolean b2 = persons.stream()
.anyMatch((e) -> e.getStatus().equals(Status.YOUNG));
System.out.println(b2); boolean b3 = persons.stream()
.noneMatch((e) -> e.getStatus().equals(Status.MIDDLE));
System.out.println(b3); Optional<Person> op = persons.stream()
.sorted((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge()))
.findFirst();
System.out.println(op.get()); Optional<Person> optional = persons.stream()
.filter((e) -> e.getStatus().equals(Status.OLD))
.findAny();
System.out.println(optional.get());
} //最大，最小
@Test
public void test2(){
long count = persons.stream()
.count();
System.out.println(count); Optional<Person> optional = persons.stream()
.max((e1,e2) -> Integer.compare(e1.getId(), e2.getId()));
System.out.println(optional.get()); Optional<Integer> op = persons.stream()
.map(Person :: getAge)
.min(Integer :: compare);
System.out.println(op.get());
} //归约
@Test
public void test3(){
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8); Integer sum = list.stream()
.reduce(0, (x,y) -> x + y);
System.out.println(sum);
System.out.println("------------"); Optional<Integer> optional = persons.stream()
.map(Person :: getAge)
.reduce(Integer :: sum);
System.out.println(optional.get());
} //收集
@Test
public void test4(){
List<String> list = persons.stream()
.map(Person :: getName)
.collect(Collectors.toList());
list.forEach(System.out :: println);
System.out.println("------------"); Set<String> set = persons.stream()
.map(Person :: getName)
.collect(Collectors.toSet());
set.forEach(System.out :: println);
System.out.println("------------"); HashSet<String> hashSet = persons.stream()
.map(Person :: getName)
.collect(Collectors.toCollection(HashSet :: new));
hashSet.forEach(System.out :: println);
} @Test
public void test5(){
Long count = persons.stream()
.collect(Collectors.counting());
System.out.println("总人数="+count);
System.out.println("----------------"); //平均值
Double avg = persons.stream()
.collect(Collectors.averagingInt(Person :: getAge));
System.out.println("平均年龄="+avg);
System.out.println("---------------"); //总和
Integer sum = persons.stream()
.collect(Collectors.summingInt(Person :: getAge));
System.out.println("年龄总和="+sum);
System.out.println("----------------"); //最大值
Optional<Person> max = persons.stream()
.collect(Collectors.maxBy((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge())));
System.out.println("最大年龄是"+max.get());
System.out.println("----------------"); //最小值
Optional<Person> min = persons.stream()
.collect(Collectors.minBy((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge())));
System.out.println("最小年龄是"+min.get());
} //分组
@Test
public void test6(){
Map<Status, List<Person>> map = persons.stream()
.collect(Collectors.groupingBy(Person :: getStatus));//根据年龄层分组
System.out.println(map);
} //多级分组
@Test
public void test7(){
Map<Status, Map<String, List<Person>>> map = persons.stream()
.collect(Collectors.groupingBy(Person :: getStatus ,Collectors.groupingBy((e) -> {
if (e.getId()%2 == 1) {
return "单号";
} else {
return "双号";
}
})));
System.out.println(map);
} //分区
@Test
public void test8(){
Map<Boolean, List<Person>> map = persons.stream()
.collect(Collectors.partitioningBy((e) -> e.getAge() > 30));
System.out.println(map);
} //IntSummaryStatistics
@Test
public void test9(){
IntSummaryStatistics iss = persons.stream()
.collect(Collectors.summarizingInt(Person :: getAge));
System.out.println(iss.getSum());
System.out.println(iss.getAverage());
System.out.println(iss.getMax());
} @Test
public void test10(){
String str = persons.stream()
.map(Person :: getName)
.collect(Collectors.joining(",","人员名单：","等"));
System.out.println(str);
}
}
并行流与串行流
并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。
/**
* FrokJoin框架
*/
public class ForkJoinCalculate extends RecursiveTask<Long>{
private static final long serialVersionUID = 1L; private long start;
private long end; private static final long THRESHOLD = 10000; public ForkJoinCalculate() { } public ForkJoinCalculate(long start, long end) {
this.start = start;
this.end = end;
} @Override
protected Long compute() {
long length = end - start ;
if (length <= THRESHOLD) {
long sum = 0;
for (long i = start; i <= end; i++) {
sum += i;
}
return sum;
}else {
long middle = (start + end) / 2;
ForkJoinCalculate left = new ForkJoinCalculate();
left.fork();//拆分子任务，同时压入线程队列 ForkJoinCalculate right = new ForkJoinCalculate();
right.fork();
return left.join() + right.join();
}
} }
测试并行流
public class TestForkJoin {
/**
* FrokJoin框架
*/
@Test
public void test1(){
Instant start = Instant.now();
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinCalculate(0,10000000000L);
Long sum = pool.invoke(task);
System.out.println(sum);
Instant end = Instant.now();
System.out.println(Duration.between(start,end).toMillis());
}
/**
* for循环
*/
@Test
public void test2(){
Instant start = Instant.now();
long sum = 0L;
for (long i = 0; i <= 10000000000L; i++) {
sum += i;
}
System.out.println(sum);
Instant end = Instant.now();
System.out.println(Duration.between(start, end).toMillis());
}
/**
* Java8并行流
*/
@Test
public void test3(){
Instant start = Instant.now();
LongStream.rangeClosed(0, 10000000000L)
.parallel()
.reduce(0,Long :: sum);
Instant end = Instant.now();
System.out.println(Duration.between(start, end).toMillis());
}
}
接口中的默认方法与静态方法
接口中的默认方法
Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。
接口默认方法的”类优先”原则
若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时
- 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
- 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突。
接口中的静态方法
Java8 中，接口中允许添加静态方法。
public interface MyInterface {
default String getName(){
return "接口测试";
}
public static void show(){
System.out.println("接口中的静态方法");
}
}
新时间日期 API
LocalDate、LocalTime、LocalDateTime
LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。 
传统写法：
public class DateFormatThreadLocal {
private static final ThreadLocal<DateFormat> tl = new ThreadLocal<DateFormat>(){
protected DateFormat initialValue() {
return new SimpleDateFormat("yyyyMMdd");
}
};
public static Date convert(String source) throws ParseException{
return tl.get().parse(source);
}
}
public static void main(String[] args) throws InterruptedException, ExecutionException {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
Callable<Date> callable = new Callable<Date>() {
@Override
public Date call() throws Exception {
// return sdf.parse("20170521");
return DateFormatThreadLocal.convert("20170521");
}
};
ExecutorService pool = Executors.newFixedThreadPool(10);
List<Future<Date>> results = new ArrayList<>();
for (int i = 0; i < 8; i++) {
results.add(pool.submit(callable));
}
for (Future<Date> future : results) {
System.out.println(future.get());
}
//关闭资源
pool.shutdown();
}
新特性：
public static void main(String[] args) throws InterruptedException, ExecutionException {
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyyMMdd");
Callable<LocalDate> callable = new Callable<LocalDate>() {
@Override
public LocalDate call() throws Exception {
return LocalDate.parse("20170521",dtf);
}
};
ExecutorService pool = Executors.newFixedThreadPool(10);
List<Future<LocalDate>> results = new ArrayList<>();
for (int i = 0; i < 8; i++) {
results.add(pool.submit(callable));
}
for (Future<LocalDate> future : results) {
System.out.println(future.get());
}
//关闭资源
pool.shutdown();
}
LocalDate LocalTime LocalDateTime
//1.LocalDate LocalTime LocalDateTime
@Test
public void test1(){
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt); LocalDateTime ldt2 = LocalDateTime.of(2017, 05, 21, 21, 43, 55, 33);
System.out.println(ldt2); LocalDateTime ldt3 = ldt.plusYears(3);
System.out.println(ldt3); LocalDateTime ldt4 = ldt.minusMonths(5);
System.out.println(ldt4);
}
Instant 时间戳
用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算。
//2.Instant
@Test
public void test2(){
Instant now = Instant.now();
System.out.println(now); OffsetDateTime atOffset = now.atOffset(ZoneOffset.ofHours(6));
System.out.println(atOffset); Instant ins = Instant.ofEpochSecond(60);
System.out.println(ins);
}
Duration 和 Period
- Duration:用于计算两个“时间”间隔
Period:用于计算两个“日期”间隔
//3.Duration
@Test
public void test3(){
Instant now = Instant.now();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Instant now2 = Instant.now();
//计算时间差
Duration duration = Duration.between(now, now2);
System.out.println(duration.getSeconds());
System.out.println("----------------"); LocalTime lt1 = LocalTime.now();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
LocalTime lt2 = LocalTime.now();
System.out.println(Duration.between(lt1, lt2).toMillis());
} //4.Period
@Test
public void test4(){
LocalDate ld1 = LocalDate.of(2017, 1, 1);
LocalDate ld2 = LocalDate.now();
Period period = Period.between(ld1, ld2);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
}
日期的操作
- TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
//5.TemporalAdjuster:时间校正器
@Test
public void test5(){
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt); LocalDateTime ldt2 = ldt.withDayOfMonth(8);
System.out.println(ldt2); LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
System.out.println(ldt3); //自定义
LocalDateTime ldt5 = ldt.with((l) -> {
LocalDateTime ldt4 = (LocalDateTime) l;
DayOfWeek dow = ldt4.getDayOfWeek();
if (dow.equals(DayOfWeek.FRIDAY)) {
return ldt4.plusDays(3);
}else if (dow.equals(DayOfWeek.SATURDAY)) {
return ldt4.plusDays(2);
} else {
return ldt4.plusDays(1);
}
});
//下个工作日
System.out.println(ldt5);
}
1
解析与格式化
java.time.format.DateTimeFormatter 类
该类提供了三种格式化方法：
- 预定义的标准格式
- 语言环境相关的格式
- 自定义的格式
//DateTimeFormatter:格式化时间/日期
@Test
public void test6(){
DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE_TIME;
LocalDateTime ldt = LocalDateTime.now(); System.out.println(ldt);
String format = ldt.format(dtf);
System.out.println(format);
System.out.println("------------");
DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String format2 = dtf2.format(ldt);
System.out.println(format2); LocalDateTime ldt2 = ldt.parse(format2,dtf2);
System.out.println(ldt2);
}
时区的处理
Java8 中加入了对时区的支持，带时区的时间为分别为：
ZonedDate、ZonedTime、ZonedDateTime
其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式
例如 ：Asia/Shanghai 等
ZoneId：该类中包含了所有的时区信息
- getAvailableZoneIds() : 可以获取所有时区时区信息
- of(id) : 用指定的时区信息获取 ZoneId 对象
//ZonedDate ZoneTime ZoneDateTime
@Test
public void test7(){
LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
System.out.println(ldt); LocalDateTime ldt2 = LocalDateTime.now(ZoneId.of("Europe/Tallinn"));
ZonedDateTime zdt = ldt2.atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(zdt);
}
与传统日期处理的转换
其他新特性
HashMap
HashMap:减少碰撞,位置相同时,条件达到链表上超过8个,总数超过64个时,数据结构改为红黑树。
ConcurrentHashMap:取消锁分段，与HashMap相同，达到条件时，数据结构改为红黑树。
Optional 类
Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
常用方法：
- Optional.of(T t) : 创建一个 Optional 实例
- Optional.empty() : 创建一个空的 Optional 实例
- Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
- isPresent() : 判断是否包含值
- orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
- orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
- map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
- flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
/**
* Optional类
*/
public class TestOptional { @Test
public void test1(){
//参数不能为空
Optional<Person> op = Optional.of(new Person()); Person person = op.get();
System.out.println(person);
} @Test
public void test2(){
//构建空optional
Optional<Person> op = Optional.empty();
System.out.println(op.get());
} @Test
public void test3(){
//如果为null，调用empty，如果不为null，调用of
Optional<Person> op = Optional.ofNullable(null);
// Optional<Person> op = Optional.ofNullable(new Person());
if (op.isPresent()) {
System.out.println(op.get());
} //有值就用值，没值就替代
Person person = op.orElse(new Person("张三", 23));
System.out.println(person);
}
}
重复注解与类型注解
Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {
MyAnnotation[] value();
}
@Repeatable(MyAnnotations.class)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ElementType.TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value() default "aric";
}
/**
* 重复注解与类型注解
*/
public class TestAnnotation {
@MyAnnotation("hello")
@MyAnnotation("test")
public void show(@MyAnnotation("a") String str){
System.out.println(str);
}
}
Java8 新特性学习的更多相关文章
- Java8 新特性学习 Lambda表达式 和 Stream 用法案例
Java8 新特性学习 Lambda表达式 和 Stream 用法案例 学习参考文章: https://www.cnblogs.com/coprince/p/8692972.html 1.使用lamb ...
- java8 新特性学习笔记
Java8新特性 学习笔记 1主要内容 Lambda 表达式 函数式接口 方法引用与构造器引用 Stream API 接口中的默认方法与静态方法 新时间日期 API 其他新特性 2 简洁 速度更快 修 ...
- java8新特性学习：函数式接口
本文概要 什么是函数式接口? 如何定义函数式接口? 常用的函数式接口 函数式接口语法注意事项 总结 1. 什么是函数式接口? 函数式接口其实本质上还是一个接口,但是它是一种特殊的接口:SAM类型的接口 ...
- java8新特性学习1
java8增加了不少新特性,下面就一些常见的新特性进行学习... 1.接口中的方法 2.函数式接口 3.Lambda表达式 4.java8内置的四大核心函数式接口 5.方法引用和构造器引用 6.Str ...
- java8新特性学习：stream与lambda
Streams api 对 Stream 的使用就是实现一个 filter-map-reduce 过程,产生一个最终结果,或者导致一个副作用(side effect). 流的操作类型分为两种: Int ...
- java8新特性学习2
六.Stream API Java8中有两大最为重要的改变.第一个是 Lambda 表达式:另外一个则是 Stream API(java.util.stream.*).Stream 是 Java8 中 ...
- java8新特性学习笔记(二) 使用流(各种API)
筛选和切片 用谓词筛选,筛选出各个不相同的元素,忽略流中的头几个元素,或将流截断至指定长度 用谓词筛选 Stream接口支持filter方法,该操作接受一个谓词(返回一个boolean的函数) 作为参 ...
- java8新特性学习笔记(二) 流的相关思想
流是什么 流是Java API的新成员,他允许你以声明的方式处理数据集合,就现在来说,可以把他们看成遍历数据集合的高级迭代器.此外,流还可以透明地并行处理,你无须写任何多线程代码. 下面例子是新老AP ...
- Java8新特性学习笔记(一) Lambda表达式
没有用Lambda表达式的写法: Comparator<Transaction> byYear = new Comparator<Transaction>() { @Overr ...
随机推荐
- QGis+QT5.9+VS2017源码编译
1.需要软件 VS2017 QT5.9.2 CMake 3.10.2 Cygwin osgeo4w QGIS源码 2.安装VS2017 过程省略 是由于机器上已经安装了VS2017 3.安装QT5. ...
- Vue-Router + Vuex 实现单页面应用
效果查看(一个食品安全网,大家也可以发布一些食品安全的见闻,尽举手之劳): 源代码:https://pan.baidu.com/s/1i43H3LV 如果想要服务器端代码可以在评论里说明一下 利用vu ...
- laravel框架中的邮箱发送
1.设置邮件服务器登录 163邮箱设置 POP3/SMTP/IMAP勾选:POP3/SMTP服务 IMAP/SMTP服务 保存 设置客户端授权密码 2.在laravel中配置服务器 打开.env文件 ...
- 『Python』__getattr__()特殊方法
self的认识 & __getattr__()特殊方法 将字典调用方式改为通过属性查询的一个小class, class Dict(dict): def __init__(self, **kw) ...
- Starting MySQL....The server quit without updating PID file[失败]/lib/mysql/ip12189.pid). 错误一例
[root@ip12189 etc]# service mysqld startStarting MySQL....The server quit without updating PID file[ ...
- less和sass的定义和区别
less是单独的一种文件,可以理解为css的升级版: sass是一个相对新的编程语言,为web前端开发而生,可以用它来定义一套新的语法规则和函数: 区别: ① 表现方式不同:less基于javas ...
- Python爬虫之requests
爬虫之requests 库的基本用法 基本请求: requests库提供了http所有的基本请求方式.例如 r = requests.post("http://httpbin.org/pos ...
- MapServer Tutorial——MapServer7.2.1教程学习——第一节用例实践：Example1.3 Displaying Classes in a Layer
MapServer Tutorial——MapServer7.2.1教程学习——第一节用例实践:Example1.3 Displaying Classes in a Layer 一.前言 关于第一节的 ...
- webpack配置接口路径
比如在webpack.config.js中的plugins中加入 new webpack.DefinePlugin({ 'process.env.NODE_ENV': JSON.stringify(' ...
- js中css样式
1.js操作css样式 例如 div . style . width=“100px”. 就是在div标签内我们添加一个style属性,并设定了width值,这种写法会给标签带来大量的style属性,跟 ...