栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

019JDK1.8新特性(java基础)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

019JDK1.8新特性(java基础)

目录

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);
}
 等同于      
Optional opt = 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;
Optional opt3 = 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性能提升

引入了红黑树

9、IO流新增API
  • BufferedReader.line():返回文本行的流stream
  • File.lines(Path,Charset):返回文本行的流 stream
  • File.list(Path):遍历当前目录下的文件和目录
  • File.walk(Path,int,FileVisitOption):遍历某一个目录下的所有文件和指定深度的子目录
  • File.find(Path, int,BiPredicate, FileVisitOption...):查找相应的文件

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/962662.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号