Java8新特性学习

最新推荐文章于 2022-03-28 21:37:27 发布
最新推荐文章于 2022-03-28 21:37:27 发布
阅读量119 收藏
点赞数
分类专栏： 【Java】 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jxlhljh/article/details/119386850
版权

Java8新特性学习

学习Java8新特性过程的笔记内容，记录下，部分内容摘自Java菜鸟教程.

1.默认方法

接口可以有实现方法,只需在方法名前面加个 default 关键字即可实现默认方法。

  1. ##示例如
package test;
public interface Istudy {
	default void study(){
		System.out.println("i like study!");
	}
}

package test;
public class MainTest {
	public static void main(String[] args) throws Exception {
		Istudy study = new Istudy() {
		};
		study.study();
	}
}
  1. ##两个接口都有默认方法且方法名相同，比如：
public interface Vehicle {
   default void print(){
      System.out.println("我是一辆车!");
   }
}
 
public interface FourWheeler {
   default void print(){
      System.out.println("我是一辆四轮车!");
   }
}

如果一个类实现了这两个接口,解决方法1：创建自己的默认方法，来覆盖重写接口的默认方法

package test;
public class Car implements Vehicle, FourWheeler {
    public void print(){
        System.out.println("car.....");
    }
}

如果一个类实现了这两个接口,解决方法2: 使用 super 来调用具体的某一个

public class Car implements Vehicle, FourWheeler {
   public void print(){
      FourWheeler.super.print();
   }
}
  1. ##静态默认方法，接口可以声明静态方法，如：
package test;

public interface Vehicle {
	default void print(){
		System.out.println("Vehicle.print!");
	}
	// 静态方法
	static void blowHorn(){
		System.out.println("Vehicle.blowHorn()");
	}
}

进行静态默认方法的调用：

package test;

public class Test {
	public static void main(String[] args) {
		Vehicle.blowHorn();	
	}
}

2.Java Lambda 表达式

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）

lambda 表达式的语法格式：

(parameters) -> expression 或 (parameters) ->{ statements; }

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

2.1.Lambda 表达式实例

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

2.2.变量作用域

lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义），即最后一后num = 5,如果去掉，代码正常。
在这里插入图片描述
在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

String first = "";  
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错

在这里插入图片描述

3.Java 8 方法引用

方法引用使用一对冒号 :: ，通过方法的名字来指向一个方法。

3.1 静态方法引用

语法：Class::static_method，实例如下：

package test;

public class Test {
	public static void main(String[] args) {

		Converter converter = Integer::valueOf;
		Integer converted = converter.convert("1234");
		System.out.println(converted);   // 1234
	}

	public interface Converter {
		int convert(String i);
	}

}

3.2 构造器引用

语法：Class::new，或者更一般的Class< T >::new实例
PersonFactory<Person> personFactory = Person::new;

package test;
class Person {
    String firstName;
    String lastName;
    Person() {}
    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

package test;

import java.util.Arrays;
import java.util.List;

public class Test {
	public static void main(String[] args) {

		PersonFactory<Person> personFactory = Person::new;
		Person person = personFactory.create("Peter", "Parker");
		System.out.println(person);

	}

	interface PersonFactory<P extends Person> {
		P create(String firstName, String lastName);
	}
}

3.3 特定类的任意对象的方法引用：Class::method

package test;

@FunctionalInterface
interface Supplier<T> {
    T get();
}

public class Car {
    public static Car create(final Supplier<Car> supplier) {
        return supplier.get();
    }
    public void follow(final Car another) {
        System.out.println("Following the " + another.toString());
    }
    public void repair() {
        System.out.println("Repaired " + this.toString());
    }
}

package test;

import java.util.Arrays;
import java.util.List;

public class Test {
	public static void main(String[] args) {

		final Car car = Car.create( Car::new );
		final List< Car > cars = Arrays.asList( car );

		cars.forEach( Car::repair );

	}

}

3.4 特定对象的方法引用：instance::method

package test;

import java.util.Arrays;
import java.util.List;

public class Test {
	public static void main(String[] args) {

		final Car car1 = new Car();
		final Car car2 = new Car();
		final List< Car > cars = Arrays.asList( car1,car2 );

		cars.forEach( car1::follow );

	}

}

4.Java 8 函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口
在这里插入图片描述

函数式接口可以被隐式转换为 lambda 表达式。

如定义了一个函数式接口如下

package test;

@FunctionalInterface
public interface GreetingService {
    void sayMessage(String message);
}

接下来可以使用Lambda表达式来表示该接口的一个实现

package test;

import java.util.Arrays;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		GreetingService greetService1 = message -> System.out.println("Hello " + message);
		greetService1.sayMessage("test");
	}
}

4.1 Function

接受一个输入参数，返回一个结果。

package test;

import javax.sound.midi.Soundbank;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class Test {
	public static void main(String[] args) {

		Function<String, Integer> toInteger = Integer::valueOf;
		int result = toInteger.apply("123");
		System.out.println(result);
	}

}

4.2 Predicate

接受一个输入参数，返回一个布尔值结果。

package test;

import java.util.function.Predicate;

public class Test {
	public static void main(String[] args) {

		Predicate<String> predicate = (s) -> s.length() > 0;
		System.out.println(predicate.test("foo"));
	}

}

4.3 Supplier

无参数，返回一个结果。

package test;

import java.util.function.Predicate;
import java.util.function.Supplier;

public class Test {
	public static void main(String[] args) {

		Supplier<User> userSupplier = User::new;
		System.out.println(userSupplier.get());
	}

}

4.4 Consumer

代表了接受一个输入参数并且无返回的操作

package test;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Test {
	public static void main(String[] args) {

		Consumer<User> userConsumer = (p) -> System.out.println("Hello, " + p.getUsername());

		User user = new User();
		user.setUsername("testusername");
		userConsumer.accept(user);
	}

}

5.Java 8 Optional 类

用来防止NullPointerException异常的辅助类型
使用示例如下：

package test;

import java.util.Optional;

public class Test {
	public static void main(String[] args) {

		// Optional.ofNullable - 允许传递为 null 参数
		Optional<String> optional = Optional.ofNullable("helloworld");

		// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
		//Optional<String> optional2 = Optional.of(null);

		//Optional.isPresent - 判断值是否存在
		System.out.println(optional.isPresent());

		//Optional.get获取值
		System.out.println(optional.get());

		//Optional.orElse - 如果值存在，返回它，否则返回默认值
		System.out.println(optional.orElse("fallback"));

		optional.ifPresent((s) -> System.out.println(s.charAt(1)));
	}

}

6.Java 8 Stream

java.util.Stream 表示能应用在一组元素上一次执行的操作序列
将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

6.1 生成流

stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
		Stream<String> aStream  = stringStrs.stream();
		//Stream<String> aStream  = stringStrs.parallelStream();
		System.out.println(aStream);
	}
}

6.2 forEach

迭代流中的每个数据

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("abc", "def", "bc", "efg", "abcd","1234", "jkl");
		Stream<String> aStream  = stringStrs.stream();
		aStream.forEach(System.out::println);
	}
}

6.3 map

迭代每一个元素进行转换操作

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("abc", "def", "bc", "efg", "abcd","1234", "jkl");
		Stream<String> aStream  = stringStrs.stream();
		Stream<String> aStreamAfter = aStream.map(s -> (s + "ttt"));

		//打印,可看到所有的字符串后面都加了ttt.
		aStreamAfter.forEach(System.out::println);
	}
}

6.4 filter

filter 方法用于通过设置的条件过滤出元素。

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("abc", "", "", "", "","", "jkl");
		Stream<String> aStream  = stringStrs.stream();
		//将字符串长度为0的过滤掉
		Stream<String> aStreamAfter = aStream.filter((s) -> s.length() > 0);

		//打印
		aStreamAfter.forEach(System.out::println);
	}
}

6.4 limit

limit方法用于获取指定数量的流。如限制只处理3条

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("abc", "ab12", "111", "222", "","", "jkl");
		Stream<String> aStream  = stringStrs.stream();
		Stream<String> aStreamAfter = aStream.limit(3);

		//打印
		aStreamAfter.forEach(s -> System.out.println(s));

	}
}

6.5 sorted

sorted 方法用于对流进行排序。

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("81", "3", "1", "6", "7","8", "9");
		Stream<String> aStream  = stringStrs.stream();
		//转换成Integer
		Stream<Integer> aStreamAfter = aStream.map(s -> Integer.valueOf(s));

		//排序后打印
		aStreamAfter.sorted().forEach(s -> System.out.println(s));

	}
}

6.6 Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串

package test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Test {
	public static void main(String[] args) {
		List<String> stringStrs = Arrays.asList("81", "3", "1", "61", "7","8", "9");
		Stream<String> aStream  = stringStrs.stream();
		//只保留大于50的
		Stream<Integer> aStreamAfter = aStream.map(Integer::valueOf).filter(integer -> integer>50);
		//打印
		System.out.println(aStreamAfter.collect(Collectors.toList()));

	}
}

6.7 统计

一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果

package test;

import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
		IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
		System.out.println("列表中最大的数 : " + stats.getMax());
		System.out.println("列表中最小的数 : " + stats.getMin());
		System.out.println("所有数之和 : " + stats.getSum());
		System.out.println("平均数 : " + stats.getAverage());
	}
}

7.Java 8 日期时间 API

Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理
在旧版的 Java 中，日期时间 API 存在诸多问题，如非线程安全、时区处理麻烦 。

新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作

7.1 本地化日期时间 API

package test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class Test {
	public static void main(String[] args) {
		// 获取当前的日期时间
		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);
	}
}

7.2 使用时区的日期时间API

如果我们需要考虑到时区，就可以使用时区的日期时间API

package test;

import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Test {
	public static void main(String[] args) {
		Test test = new Test();
		test.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);
	}

}

7.3 Java8中进行日期格式化

package test;

import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Test {
	public static void main(String[] args) {
		Instant date = Instant.now();//代替date
		System.out.println("instant:"+date);
		LocalDate date2 = LocalDate.now();
		System.out.println("LocalDate:"+date2);
		LocalDateTime date3 = LocalDateTime.now();//代替calendar
		System.out.println("LocalDateTime:"+date3);
		DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");//代替simpleDateFormat
		System.out.println("DateTimeFormatter:"+dtf.format(date3));
	}
}
冰之杍
关注
专栏目录
Java8新特性
lanleihhh的博客
11-07 1958
Stream允许我们以声明式的方式处理数据集合,可以将Stream看作是遍历数据集合的高级迭代器。Stream 与Lambda表达式结合使用，将使编码效率大大提高，可读性增强。Stream与IO中的是不同的概念操作案例：使用stream将集合中的手机按照序号num从小到大排序：Stream流的操作顺序Stream语法Lambda表达式是一个匿名函数，可以将Lambda表达式理解为一段可以传递的代码（将代码段数据一样传递）。使用Lambda表达式可以写出更简洁，更灵活的代码。
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性
09-02
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性 自学java的同行们应该都要学习java8的新特性，譬如：（Lambda、Stream、LocalDate等）！本人在学习java的时候看的是波哥的视频，确实讲的不错，很...
Java8学习资料
03-07
学习Java的资料打开eclipse时出现了Failed to load the JNI shared library，这个问题一般是eclipse和JDK位数不一样
java8特性
AIfurture的博客
08-10 332
JAVA8新特性 1、方法引用 2、函数式接口 3、Lambda表达式 4、StreamAPI 5、Optional类 6、时间日期API 1、方法引用 方法引用通过方法的名字来指向一个方法。 方法引用可以使语言的构造更紧凑简洁，减少冗余代码。 方法引用使用一对冒号 :: 。 eg: package com.runoob.main; @FunctionalInterface public inte...
java8新特性学习笔记
weixin_42032770的博客
08-21 949
1、速度更快 jdk1.8对底层做了优化，使得速度更快了。jdk1.8取消了永久区，取而代之的是增加了元空间（MetaSpace），元空间直接使用了物理内存（RAM），因此运行速度会更快。 jdk1.8之后对哈希表做了优化，在jdk1.8之前，哈希表的结构是数组+链表，jdk1.7使用的是头插法，jdk1.7用的单链表是纵向延伸的。jdk1.8之后，增加了红黑树，jdk1.8之后的哈希表的结构是数组+链表+红黑树。jdk1.8的哈希表用的是尾插法，当哈希表容量达到总容量的3/4的时候（负载因子0..
java 8 新特性学习
qq_45007035的博客
03-28 542
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、Lambda 是什么？二、基本语法三、自己练习深刻理解使用四、java 8 四大内置核心函数式接口 前言 优化简洁的开发Java 8新特性 Lambda 表达式 一、Lambda 是什么？ Lambda 是Jdk 1.8 的一种新特性。 优点: 速度更快 代码更少 强大的 Stream API 便于并行 最大减少空指针异常 Optical 二、基本语法 //1.无参无返回Lambda 表达式 .
java8新特性学习笔记.rar
07-07
但是我们实际开发中真正用到的新特性并不多，大多数人也仅仅用用lambda，而对于其他的特性，比如：多重注解、Date API、函数式接口等等并没有使用起来，本资源包含作者的学习java8新特性的笔记，笔记中有讲解和代码...
java8集合源码分析-java8-learning:Java8新特性学习
06-04
Java8特性 [TOC] 1. Lambda 表达式 与传统匿名内部类写法的对比 无返回值 // 传统写法 new Thread(new Runnable() { @Override public void run() { System.out.println("worker thread is running"); } }).start();...
Java8-JDK8-新特性学习
11-17
Java 8，也被称为JDK 8，是Java发展历程中的一个重要里程碑，引入了...以上只是Java 8新特性的一部分，这些改变使得Java更加现代化，提高了开发效率，降低了维护成本。学习并掌握这些特性对于Java开发者来说至关重要。
JAVA8新特性学习
雪莲嘉乐--专栏
10-15 375
JAVA8的出现，为程序员们带了了很多的方便，新增加了很多新的特性，现在和大家一起学习学习。 1、Java8允许我们对接口添加一个默认的非抽象的实现类。只需要default关键字即可，这个特征又叫做扩展方法：                例如：                        interface    Test{
java8新特性学习
RowandJJ
09-28 2064
内容： 1. lambda表达式 2. streamAPI 3. 内置函数接口 4. 接口默认实现方法 5. android中使用lambda/streamAPI=======1.lambda表达式: 几种形式:()->statement ()->(statement) ()->{statement}以Thread为例:new Thread(new Runnable(){ pub
Java8 新特性学习
innerpeacez成长之路
06-05 5261
1、接口中的默认方法 Java8中允许接口中包含具有具体实现的方法，这种方法被称为“默认方法”，使用default关键字修饰。 如： public interface MyInterface { String notDefault(); default String testDefault() { return "Hello Default Metho...
JAVA8新特性学习文档或者比较优秀的博文
最新发布
05-25
以下是一些比较优秀的 Java 8 新特性学习文档或博文： 1. Oracle 官方文档：https://docs.oracle.com/javase/8/docs/index.html 2. Java 8 新特性系列文章：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值