JAVA8的几个比较常见的新特性:
- Lambda表达式
- Stream API
- Date API
- Optional API
- 接口的默认方法和静态方法
1.Lambda表达式
它允许我们将函数当成参数传递给某个方法,或者把代码本身当作数据处理。最简单的Lambda表达式可由逗号分隔的参数列表、->符号和语句块组成。
- Lambda语法如下
(parameters) -> expression
或
(parameters) -> {statements;}
- 使用Lambda的好处
1.不需要声明参数类型,由编译器统一识别参数值。
2.当参数为一个的时候,不需要定义圆括号,但多个参数的时候需要定义圆括号。
3.如果函数主体只有一个语句,就不用使用大括号。
4.如果函数主体只有一个返回值可以不指定返回类型,由编译器自动识别。 - 举个例子
public static void mian(String[] args) {
// 传统编程,不使用Lambda
List<String> list = Arrays.asList("a", "b", "c");
for (String i : list) {
System.out.println("-----不使用Lambda");
System.out.println("i is : " + i);
}
// 使用Lambda(1)
System.out.println("-----使用Lambda(1)");
list.forEach(k -> System.out.println("k is : " + k));
// 使用Lambda(2)
list.forEach(k -> {
System.out.println("-----使用Lambda(2)");
System.out.println("k is : " + k);
});
// 使用Lambda(3),不写返回值类型,默认由编译器识别
System.out.println("-----使用Lambda(3)");
list.sort((e1, e2) -> e1.compareTo(e2));
// 使用Lambda(4)
System.out.println("-----使用Lambda(4)");
list.sort((e1, e2) -> {
int result = e1.compareTo(e2);
return result;
});
}
2.Stream API
新增的Stream API(java.util.stream)将生成环境的函数式编程引入了Java库中。可以通过将List、Set、Array等对象转换成流进行操作。
流操作分为两种:
中间操作:会返回一个全新的流对象,不会影响最初的流。
最终操作:会将流进行转换或者操作,返回非流对象。
中间操作
- java Stream distinct() 去除流中重复的对象,并返回一个流。
public static void main(String[] args) {
List<String> list = Arrays.asList("abc", "abc", "bc", "efg", "abcd", "", "jkl");
System.out.println("去重前:" + list);
System.out.println("去重后:" + list.stream().distinct().collect(Collectors.joining(",")));
}
- java Stream skip(long n)跳过Stream中的前n个对象,将其他对象返回一个Stream。如果n超过了Stream中对象的个数,则会返回一个空的Stream。
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
System.out.println("skip:");
numbers.stream().skip(2).forEach(System.out::println);
}
- java Stream limit(long maxSize) 截取Stream的前maxSize个对象,并形成一个新Stream。
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
System.out.println("limit:");
numbers.stream().limit(4).forEach(System.out::println);
}
- java Stream filter(Predicate<? super T> predicate)根据给定的predicate来过滤对象,返回满足条件的对象构成的Stream。
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
System.out.println("filter:");
numbers.stream().filter(i -> i % 2 == 0).distinct().forEach(System.out::println);
}
- Stream map(Function<? super T, ? extends R> mapper)通过给定的mapper,将T类型的流转换为R类型的Stream。
public static void main(String[] args) {
List<String> str = Arrays.asList("a", "b", "c", "d");
System.out.println("map:");
str.stream().map(String::toUpperCase).collect(Collectors.toList()).forEach(System.out::println);
}
- java Stream sorted(); Stream sorted(Comparator<? super T> comparator) sorted方法可以对Stream进行排序。排序的对象必须实现Comparable,如果没实现会抛出ClassCastException;不提供comparator时,则会调用compareTo方法。
public static void main(String[] args) {
List<Integer> list = Arrays.asList(6, 5, 4, 3, 2, 1);
System.out.println("倒序:" + list);
System.out.println("sorted:");
list.stream().sorted().forEach(System.out::println);
}
最终操作
- Optional min(Comparator<? super T> comparator)& Optional max(Comparator<? super T> comparator)
根据给定的comparator返回Stream中的max或min。 - long count()
返回Stream中对象的个数。 - <R, A> R collect(Collector<? super T, A, R> collector)
根据给定的collector对Stream中的元素进行操作,返回复杂数据结构的对象。用于将Stream中的对象转换成我们想要的结构,如list、map、set等。
前例中就使用collect(Collectors.toList())将Stream中的对象转换成List。 - Object[] toArray()
将Stream中的对象返回成一个Object数组。 - void forEach(Consumer<? super T> action)
顾名思义,对Stream中每个元素进行action操作,但forEach是一个最终操作,一般在结束时查看对象使用。
3.Date API
- Java8在java.time包下提供了很多新的API。以下为两个比较重要的API。
1.Local(本地) − 简化了日期时间的处理,没有时区的问题。
2.Zoned(时区) − 通过制定的时区处理日期时间。 - 在Java8之前在处理时间这部分,通常使用java.util.Date和java.text.SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = new Date();
String time = sdf.format(d);
System.out.println("time is : " + time);
- Java8本地化日期时间API:
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8tester = new Java8Tester();
java8tester.testLocalDateTime();
}
public void testLocalDateTime(){
// 获取当前的日期时间
LocalDateTime currentTime = LocalDateTime.now();
System.out.println("当前时间: " + currentTime);
LocalDate date1 = currentTime.toLocalDate();
System.out.println("date1: " + date1);
Month month = currentTime.getMonth();
int day = currentTime.getDayOfMonth();
int seconds = currentTime.getSecond();
System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
System.out.println("date2: " + date2);
// 12 december 2014
LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
System.out.println("date3: " + date3);
// 22 小时 15 分钟
LocalTime date4 = LocalTime.of(22, 15);
System.out.println("date4: " + date4);
// 解析字符串
LocalTime date5 = LocalTime.parse("20:15:30");
System.out.println("date5: " + date5);
}
}
- Java8使用时区的日期时间API:
import java.time.ZoneId;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8tester = new Java8Tester();
java8tester.testZonedDateTime();
}
public void testZonedDateTime(){
// 获取当前时间日期
ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
System.out.println("date1: " + date1);
ZoneId id = ZoneId.of("Europe/Paris");
System.out.println("ZoneId: " + id);
ZoneId currentZone = ZoneId.systemDefault();
System.out.println("当期时区: " + currentZone);
}
}
4.Optional API
- 首先,Optional 类的引入很好的解决空指针异常。Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
- Optional是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。
import java.util.Optional;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8Tester = new Java8Tester();
Integer value1 = null;
Integer value2 = new Integer(10);
// Optional.ofNullable - 允许传递为 null 参数
Optional<Integer> a = Optional.ofNullable(value1);
// Optional.of - 如果传递的参数是 null,抛出异常 NullPointerException
Optional<Integer> b = Optional.of(value2);
System.out.println(java8Tester.sum(a,b));
}
public Integer sum(Optional<Integer> a, Optional<Integer> b){
// Optional.isPresent - 判断值是否存在
System.out.println("第一个参数值存在: " + a.isPresent());
System.out.println("第二个参数值存在: " + b.isPresent());
// Optional.orElse - 如果值存在,返回它,否则返回默认值
Integer value1 = a.orElse(new Integer(0));
//Optional.get - 获取值,值需要存在
Integer value2 = b.get();
return value1 + value2;
}
}
5.接口的默认方法和静态方法
这个我平时用的比较少,就简单介绍一下用法。
public interface test {
default void print(){
System.out.println("默认方法");
}
static void staticVoid(){
System.out.println("静态方法");
}
}