java8中重要的4个新特性：
- Lambda
- Stream
- Optional
- 日期时间API
- 接口方法（default和static方法，jdk9可定义private方法）
一、Lambda
import java.util.Comparator;
import java.util.function.Consumer; /**
* @author zhaojigang
* @date 2018/5/19
*/
public class LambdaTest {
/**
* Lambda 是一个匿名函数。
* 1、语法
* Lambda表达式引入了操作符为"->"，该操作符将Lambda分为两个部分：
* 左侧:指定了Lambda表达式需要的所有参数
* 右侧:指定了Lambda体，即Lambda表达式要执行的功能。
*
* 2、示例
*/
public void testLambda() {
/**
* 语法格式一：无参，无返回值
*/
Runnable task = () -> System.out.println("hello lambda");
/**
* 语法格式二：一个参数，无返回值
* 注意：参数类型可以通过
*/
Consumer<String> consumer = str -> System.out.println(str);
/**
* 语法格式三：一个参数，有返回值
* 注意：当Lambda体只有一条语句时，省略大括号和return
*/
Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);
} /**
* 函数式接口：只包含一个抽象方法的接口。
* 1、可以通过Lambda表达式来创建该接口的对象
* 2、可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口
*
* Java内置了四大核心函数式接口：
* 1、Consumer<T>：void accept(T t)，消费型接口
* 2、Supplier<T>：T get()，供给型接口
* 3、Function<T, R>：R apply(T t)，函数型接口
* 4、Predicate<T>：boolean test(T t)，断言型接口
* 还有部分子接口。
*/
public void testFunctionalInterface() {
Consumer<String> consumer = str -> System.out.println(str);
}
}
二、Stream
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.stream.LongStream; /**
* @author zhaojigang
* @date 2018/5/19
*/
public class StreamTest { static List<Integer> integerList = new ArrayList<Integer>() {{
add(1);
add(2);
add(3);
add(4);
add(5);
add(5);
add(5);
}}; static List<Integer> integerList2 = new ArrayList<Integer>() {{
add(10);
add(20);
add(30);
}}; static Map<String, List<Integer>> map1 = new HashMap<>(); static {
map1.put("list1", integerList);
map1.put("list2", integerList2);
} /**
* 分片与筛选
*/
public static void test1() {
integerList.stream()
.filter(x -> x > 2) // 3,4,5,5,5
.skip(2) //5,5,5
.limit(2) //5,5 短路:一旦获取到2个元素后不再向后迭代
.distinct() //
.forEach(System.out::println);
} /**
* 映射
* map(Function f)：接收一个函数作为参数，该函数会被应用到每个元 素上，并将其映射成一个新的元素
* flatMap(Function f)：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
*/
public static void test2() {
integerList.stream()
.map(x -> x + 10)
.forEach(System.out::println); map1.values().stream()
.flatMap(x -> x.stream()) // x是每一个List，flatMap将每一个List的Stream合并起来
.forEach(System.out::println); } /**
* 排序
* sorted()：产生一个新流，其中按自然顺序排序（按照元素的Comparable接口）
* sorted(Comparator comp)：产生一个新流，其中按比较器顺序排序（按照自定义的Comparator）
*/
public static void test3() {
integerList.stream()
.sorted()
.forEach(System.out::println); integerList.stream()
.sorted((x, y) -> {
if (x < y) {
return 1;
} else {
return -1;
}
})
.forEach(System.out::println); } /**
* 查找与匹配
* allMatch(Predicate p)：检查是否匹配所有元素
* anyMatch(Predicate p)：检查是否至少匹配一个元素
* noneMatch(Predicate p)：检查是否没有匹配所有元素
* findFirst()：返回第一个元素
* findAny()：返回当前流中的任意元素
* count()：返回流中元素总数
* max(Comparator c)：返回流中最大值
* min(Comparator c)：返回流中最小值
*/
public static void test4() {
final boolean allMatch = integerList.stream().allMatch(x -> x > 4);
final boolean anyMatch = integerList.stream().anyMatch(x -> x > 4);
final boolean noneMatch = integerList.stream().noneMatch(x -> x > 4);
final Optional<Integer> first = integerList.stream().filter(x -> x > 3).findFirst();
final Optional<Integer> any = integerList.stream().filter(x -> x > 3).findAny();
final long count = integerList.stream().filter(x -> x > 4).count();
final Optional<Integer> max = integerList.stream()
.max((x, y) -> {
if (x < y) {
return 1;
} else {
return -1;
}
}); } /**
* 规约
* <p>
* reduce(T iden, BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回T，其中iden是初始值
* reduce(BinaryOperator b)：可以将流中元素反复结合起来，得到一个值。返回Optional<T>
*/
public static void test5() {
// 计算：100+1+2+3+4+5+5+5
final Integer sum = integerList.stream().reduce(100, (x, y) -> x + y);
final Optional<Integer> sumOptional = integerList.stream().reduce((x, y) -> x + y);
} /**
* 收集
* 常用：
* 1、将流元素收集到List：List<Employee> emps= list.stream().collect(Collectors.toList());
* 2、将流元素收集到Set：List<Employee> emps= list.stream().collect(Collectors.toSet());
* 3、连接流中每个字符串：String str= list.stream().map(Employee::getName).collect(Collectors.joining());
* 4、分组： Map<Emp.Status, List<Emp>> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
*
* 不常用：
* 1、根据true或false进行分区：Map<Boolean,List<Emp>>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));
* 2、根据比较器选择最大值：Optional<Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
* 3、根据比较器选择最小值：Optional<Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
* 4、将流元素收集到任意指定集合：Collection<Employee> emps=list.stream().collect(Collectors.toCollection(ArrayList::new));
* 5、计算流中元素的个数：long count = list.stream().collect(Collectors.counting());
* 6、对流中元素的属性求和：int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
* 7、计算流中元素Integer属性的平均值：double avg= list.stream().collect(Collectors.averagingInt(Employee::getSalary));
*/
public static void test6() {
} /**
* 并行流与串行流
* 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。
* 底层：fork/join
* Stream API可以声明性地通过parallel()与sequential()在并行流与顺序流之间进行切换
*/
public static void test7(){
long start = System.currentTimeMillis(); final OptionalLong sum = LongStream.rangeClosed(0, 100000000000L)
.parallel()
.reduce(Long::sum); System.out.println(sum + "-" + (System.currentTimeMillis() - start));
} public static void main(String[] args) {
test7();
}
}
三、Optional
import java.util.Optional; /**
* @author zhaojigang
* @date 2018/5/19
*/
public class OptionalTest { public static void main(String[] args) {
// String godName = "shijia";
String godName = null;
// 常用方式
final String god = Optional.ofNullable(godName).orElse("yesu");
System.out.println(god);
}
}
四、日期时间API
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter; /**
* @author zhaojigang
* @date 2018/5/19
*/
public class TimeTest { /**
* 一、日期创建：
* LocalDate localDate = LocalDate.now();
* LocalTime localTime = LocalTime.now();
* LocalDateTime localDateTime = LocalDateTime.now();
*
* LocalDate localDate = LocalDate.of(2016, 10, 26);
* LocalTime localTime = LocalTime.of(02, 22, 56);
* LocalDateTime localDateTime = LocalDateTime.of(2016, 10, 26, 12, 10, 55);
*
* 二、日期加减运算
* plusDays, plusWeeks, plusMonths, plusYears
* minusDays, minusWeeks, minusMonths, minusYears
* plus, minus
*
* 三、日期比较计算
* isBefore, isAfter
*
* 四、是否闰年
* isLeapYear
*
* 五、时间戳与时间间隔运算
* Instant 时间戳：以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算
* Duration:用于计算两个“时间”间隔
* Period:用于计算两个“日期”间隔
*
* 六、时间校正器
* TemporalAdjuster/TemporalAdjusters 调整时间：例如获取下一个周日等
*
* 七、日期解析和格式化
* java.time.format.DateTimeFormatter类
*/
public static void main(String[] args) {
/**
* 计算时间间隔
*/
Instant in1 = Instant.now();
Instant in2 = Instant.now();
System.out.println(Duration.between(in1, in2).toMillis()); /**
* 日期格式化
*/
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime time1 = LocalDateTime.now();
String formatDateTime = time1.format(formatter); /**
* 日期解析
*/
LocalDateTime dateTime = LocalDateTime.parse(formatDateTime, formatter);
}
}
日期操作我们通常会使用Apache commons包，但是这样就会引入一个包，能够使用java本身的就是用java本身的。
五、接口方法
/**
* @author zhaojigang
* @date 2018/5/19
*/
public class InterfaceTest {
public static void main(String[] args) {
MyImpl myClass = new MyImpl();
System.out.println(myClass.getName());
System.out.println(MyInterface.getAge());
}
} interface MyInterface {
default String getName(){
return "nana";
} static Integer getAge(){
return 18;
}
} /**
* 若一个接口中定义了一个默认方法，而另外一个父类中又定义了一个同名的方法时，取父类
* 若一个接口中定义了一个默认方法，而另外一个实现接口中又定义了一个同名的方法时，实现类需要执行重写其中一个
*/
class MyImpl implements MyInterface {
}
在jdk9中，接口中可以定义private方法。