目录
1、Lambda表达式
2、Stream API
3、Optional类
4、双冒号“::”
5、接口default 关键字
6、函数式接口(接口只含一个抽象方法)
7、时间和日期API
8、HashMap性能提升
9、IO流新增API
Java 8 是oracle公司于2014年3月发布,可以看成是自Java 5 以来最具革命性的版本。比较受重视的就是下面这些新特性,实际上还有js升级,注解升级等,不过主要关注这几些常用的新特性就够用了,尤其是lambda表达式和Stream API
1、Lambda表达式
基于很多代码是有一定规律的,而且如果按原有的语法规则进行书写,就会产生大量的代码,那么,lambda的诞生在某些语法上简化了代码的书写,也提高了代码的可读性。
1、表达式写法
(parameters) -> { statements; }
或parameter -> statements;
当参数只有一个的时候,parameters外面的小括号()可以去掉,当表达式只有一句的时候,statements外面的大括号{}也可以去掉
2、什么时候用?
(1)函数式接口
指的是接口内只有一个方法,当我们使用这个方法的时候,可以用lambda表达式代替匿名类
跟下面的线程部分一起演示吧
(2)线程的创建和使用
比如Runnable接口,以前的使用方式:
new Thread(new Runnable(){
@Override
public void run()
{
System.out.println("No use lambda.");
}
}).start();
用lambda表达式:
new Thread(()->System.out.println("use Lambda")).start();
当然,run()方法用lambda表达式也能再扩展一下,增加一些内容
public static void main(String[] args) {
new Thread(() -> {
Thread.currentThread().setName("线程一");
for (int i = 0; i < 5; i++) {
System.out.println("第" + i + "秒");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
(3)简化集合类的使用
比如说集合的遍历、排序等功能
void testCollection() {
List list = new ArrayList();
list.add(1);
list.add(3);
list.add(5);
list.add(2);
list.sort(Comparator.naturalOrder());
list.forEach(i->System.out.println(i));
Map map = new HashMap();
map.put("小刺猬",2);
map.put("小蚂蚁",1);
map.put("小猪猪",50);
map.put("小喵喵",10);
map.forEach((key,value)->{value = value+5;System.out.println(key+"的体重是"+value+"kg");});
}
输出结果:
1
2
3
5
小刺猬的体重是7kg
小蚂蚁的体重是6kg
小猪猪的体重是55kg
小喵喵的体重是15kg
(4)基于Stream
这个也是1.8新特性中一个重要的点,要在下面要详细地说
2、Stream API
流是 Java API 的新成员,它允许以声明性方式处理数据集合,可以把它们看成遍历数据集的高级迭代器
它更像一个高级版本的 Iterator,原始版本的 Iterator,用户只能显式地一个一个遍历元素并对其执行某些操作
比如说我们要遍历一个list,并对其中的数据做一些改变,用之前的遍历方式:
for (Animal animal : list) {
animal.setWeight(animal.getWeight()*10);
}
用stream
list.stream().forEach(animal->{
animal.setWeight(animal.getWeight()*10);
});
流中还提供了一些其他的常用方法
- 遍历:list.stream().forEach(animal-> System.out.println(animal));
- 取最大值:list.stream().max(Comparator.comparing(Animal::getWeight)).get();
- 取最小值:list.stream().min(Comparator.comparing(Animal::getWeight)).get();
- 取对象中某一属性转成list:list.stream().map(Animal::getWeight).collect(Collectors.toList());
- 筛选符合条件的元素:list.stream().filter(animal->animal.getWeight()>50).collect(Collectors.toList());
- 排序:list.stream().sorted(Comparator.comparing(Animal::getWeight)).collect(Collectors.toList());
代码演示:
(“类::sth”用来访问类的的构造方法,对象方法,静态方法的)
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Animal("小刺猬",1));
list.add(new Animal("小猪猪",10));
list.add(new Animal("小黄鸭",2));
list.add(new Animal("小喵喵",5));
list.add(new Animal("小小鸟",1));
list.add(new Animal("小坦克",500));
System.out.println("=======普通遍历方式========");
for (Animal animal : list) {
System.out.println(animal.toString());
}
list.stream().forEach(animal->{
animal.setWeight(animal.getWeight()*10);
});
System.out.println("=======流遍历处理之后遍历========");
list.stream().forEach(animal-> System.out.println(animal));
Animal animal1 = list.stream().max(Comparator.comparing(Animal::getWeight)).get();
System.out.println("最重的小动物是:"+animal1);
Animal animal2 = list.stream().min(Comparator.comparing(Animal::getWeight)).get();
System.out.println("最轻的小动物是:"+animal2);
List weights = list.stream().map(Animal::getWeight).collect(Collectors.toList());
System.out.println("所有小动物的体重:"+weights);
List collect = list.stream().filter(animal->animal.getWeight()>50).collect(Collectors.toList());
System.out.println("体重都大于50的小动物集合:"+collect);
List collect2 = list.stream().sorted(Comparator.comparing(Animal::getWeight)).collect(Collectors.toList());
System.out.println("=======小动物们根据体重排序:=======");
collect2.stream().forEach(animal->System.out.println(animal));
}
3、Optional类
Optional类是Java8为了解决null值判断问题。Optional是一个容器,里面放着我们的返回值(就是真正要用的东西),但是这个真正要用的东西可能是null呀,所以每次都要判断,但是Optional不可能是null。所以不要在判断是否为null了
常用的方法:
(1)创建
Optional类的两个构造方法都是private型的,因此类外部不能显示的使用new Optional()的方式来创建Optional对象,但是提供了三个静态的方法来创建:
- Optional.empty(): 创建一个空的 Optional 实例
- Optional.of(T t):创建一个 Optional 实例,当 t为null时抛出异常
- Optional.ofNullable(T t):创建一个 Optional 实例,但当 t为null时不会抛出异常,而是返回一个空的实例
如果用of创建了一个实例,参数为null时会抛出空指针异常
(2)获取
- get():获取optional实例中的对象,当optional 容器为空时报错
(3)判断
- isPresent():判断optional是否为空,如果空则返回false,否则返回true
- ifPresent(Consumer c):如果optional不为空,则将optional中的对象传给Comsumer函数
- orElse(T other):如果optional不为空,则返回optional中的对象;如果为null,则返回 other 这个默认值
- orElseGet(Supplier
other):如果optional不为空,则返回optional中的对象;如果为null,则使用Supplier函数生成默认值other - orElseThrow(Supplier
exception):如果optional不为空,则返回optional中的对象;如果为null,则抛出Supplier函数生成的异常
String x= "abc";
if (x != null) {
System.out.println(x);
}
等同于
Optionalopt = Optional.of("abc");
opt.ifPresent(x->System.out.println(x));或者
Optional
opt2 = Optional.ofNullable("abc");
if(opt2.isPresent()) System.out.println(opt2.get());
orElse代码演示:
String x = null; Optionalopt3 = Optional.ofNullable(x); System.out.println(opt3.orElse("空")); String y = "y不为空"; Optional opt4 = Optional.ofNullable(y); System.out.println(opt4.orElse("空"));
输出结果:
空
y不为空
(4)过滤
- filter(Predicate
p):如果optional不为空,则执行断言函数p,如果p的结果为true,则返回原本的optional,否则返回空的optional
void testMaohao() {
List list = new ArrayList();
list.add(new Animal("小刺猬",1));
list.add(new Animal("小猪猪",10));
list.add(new Animal("小黄鸭",2));
list.add(new Animal("小喵喵",50));
list.add(new Animal("小小鸟",1));
list.add(new Animal("小坦克",500));
for (Animal animal : list) {
Optional opt = Optional.ofNullable(animal).filter(a->a.getWeight()>10);
System.out.println(animal.getName()+(!opt.isPresent()?"不符合条件":"符合条件:"));
opt.ifPresent(System.out::println);
}
}
输出结果
小刺猬不符合条件
小猪猪不符合条件
小黄鸭不符合条件
小喵喵符合条件:
Animal [name=小喵喵, weight=50]
小小鸟不符合条件
小坦克符合条件:
Animal [name=小坦克, weight=500]
(5)映射
- map(Function
mapper):如果optional不为空,则将optional中的对象 t 映射成另外一个对象 u,并将 u 存放到一个新的optional容器中。 - flatMap(Function< T,Optional> mapper):跟上面一样,在optional不为空的情况下,将对象t映射成另外一个optional
区别:map会自动将u放到optional中,而flatMap则需要手动给u创建一个optional
map()方法可以对值做一些处理,将一个操作作用于里面的东西。比如,字符串去掉首尾空格后打印出来,或者对数字做一些运算
public class Test02Lambda {
public static void main(String[] args) {
testMaohao();
}
private static Integer test(Integer a) {
return a*5;
}
private static void testMaohao() {
List list = new ArrayList();
list.add(new Animal("小刺猬 ",1));
list.add(new Animal(" 小猪猪",10));
for (Animal animal : list) {
Optional opt = Optional.ofNullable(animal.getWeight()).map(Test02Lambda::test);
System.out.println(opt.get());
}
}
}
4、双冒号“::”
使用双冒号是为了省略item ->这一部分,不用传参,直接类::方法
有两个必要条件:
- Lambda表达式内部只有一条表达式
- 不需要写参数item也知道如何使用item的情况
代码演示:
void testMaohao() {
List list = new ArrayList();
list.add(new Animal("小刺猬",1));
list.add(new Animal("小猪猪",10));
list.add(new Animal("小黄鸭",2));
list.add(new Animal("小喵喵",5));
list.add(new Animal("小小鸟",1));
list.add(new Animal("小坦克",500));
list.forEach(System.out::println);
}
5、接口default 关键字
在1.8之前,接口里面只能有抽象方法,1.8之后引入了关键字default,通过使用 default 修饰方法,可以在接口里面定义具体的方法实现,如下:
public interface TestInteface{
public void test1();
public default void test2(){
System.out.println("我不是抽象方法");
}
}
public class TestIntefacImpl implements TestInteface {
@Override
public void test1() {
System.out.println("我是被重写的抽象方法");
}
}
这样定义方法的主要作用是定义一个默认方法,也就是说这个接口的实现类实现了这个接口之后,不用管这个 default 修饰的方法,也可以直接调用,如下:
public static void main(String[] args) {
TestInteface ti = new TestIntefacImpl();
ti.test1();
ti.test2();//没被重写依然可以直接调用
}
6、函数式接口(接口只含一个抽象方法)
以前要调用这个抽象方法,要么新建一个类然后new子类对象来调用,要么new一个匿名类(如下)
public static void main(String[] args) {
//方式一、new子类对象调用
TestInteface ti = new TestIntefacImpl();
ti.test1();
ti.test2();
//方式二、匿名类调用
(new TestInteface() {
@Override
public void test1() {
System.out.println("我是通过匿名类方式调用的");
}
}).test1();
//方式三、函数式接口
TestInteface x = ()-> System.out.println("我是通过函数式接口方式调用的");
x.test1();
}
其实相当于去掉了函数声明,增加了一个“->”,因为这个接口里就这么一个需要重写的匿名函数,不用声明了,但是返回后需要再调用一下test1(),调用省不掉的,别忘了!!!
对比一下这俩:
7、时间和日期API
Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API:
-
Local(本地) − 简化了日期时间的处理,没有时区的问题。
-
Zoned(时区) − 通过制定的时区处理日期时间
public static void main(String[] args) {
LocalDateTime currentTime = LocalDateTime.now();
System.out.println("当前时间: " + currentTime);
ZonedDateTime date = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
System.out.println("date: " + date);
}
8、HashMap性能提升
引入了红黑树



