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 ...
随机推荐
- SpringBoot 配置阿里巴巴Druid连接池
在Spring Boot下默认提供了若干种可用的连接池(dbcp,dbcp2, tomcat, hikari),当然并不支持Druid,Druid来自于阿里系的一个开源连接池,它提供了非常优秀的监控功 ...
- Probability和Likelihood的区别
Bayes for Beginners: Probability and Likelihood 好好看,非常有用. 以前死活都不理解Probability和Likelihood的区别,为什么这两个东西 ...
- Linux出现wrong ELF class: ELFCLASS64
安装软件时出现问题 ×.so.×:wrong ELF class: ELFCLASS64 ,大致的意思是软件是32位的,需要32位的 ×.so.×动态链接库,而系统是64位的所提供的该 动态链接库 ...
- 随机森林RF、XGBoost、GBDT和LightGBM的原理和区别
目录 1.基本知识点介绍 2.各个算法原理 2.1 随机森林 -- RandomForest 2.2 XGBoost算法 2.3 GBDT算法(Gradient Boosting Decision T ...
- 出现Unable to locate appropriate constructor on class 错误可能的原因
1)参数构造器的参数类型是否正确2)参数构造器的顺序和hql中的顺序是否一致3)参数构造器的参数个数是否和hql中的个数一致4)参数构造器的参数类型是否TimeStamp
- [luogu P3648] [APIO2014]序列分割
[luogu P3648] [APIO2014]序列分割 题目描述 小H最近迷上了一个分隔序列的游戏.在这个游戏里,小H需要将一个长度为n的非负整数序列分割成k+1个非空的子序列.为了得到k+1个子序 ...
- js中通过Object.prototype.toString方法----精确判断对象的类型
判断是否为函数 function isFunction(it) { return Object.prototype.toString.call(it) === '[object Func ...
- open live writer安装教程和账号配置
第一步:Open Live Writer软件下载.官方地址:http://openlivewriter.org/ 第二步:双击安装文件(OpenLiveWriterSetup.exe),然后点击下一步 ...
- keil安装
安装准备: 一个keil安装程序,一个注册机 安装步骤.... 软件安装: 打开C51V901.EXE 安装程序 点击Next, 同意上述证书协议 重复点击Next,知道出现finish停下. 3个多 ...
- 自用IP查询网址 - 地址 - 归属地 - 地理位置 - 2017.5
下面速度较快排行 http://city.ip138.com/ip2city.asp http://1212.ip138.com/ic.asp http://www.taobao.com/help/g ...