以下是JDK1.8版本中的以下新特性
1.在interface ,接口中使用defalut修饰的方法可以不被接口实现类重写(默认方法)
public interface IJDKIntafaceTest {
//使用关键字 defalut 修饰的接口里面的方法,接口的实现类可以不用实现
default String getStringPrint() {
return "This is JDK1.8 new trait";
}
}
public class JDKIntafaceTestImpl implements IJDKIntafaceTest {} 当然也可以实现重写 public class JDKIntafaceTestImpl implements IJDKIntafaceTest {
@Override
public String getStringPrint() {
// TODO Auto-generated method stub
return IJDKIntafaceTest.super.getStringPrint();
}
} 2.在interface ,接口中可以定义静态方法并且提供实现该方法(静态方法)
static String getStringPrintStatic(){
return "This is JDK1.8 new trait interface statice";
};
3.JDK1.8的最大亮点,新增了Lambda表达式,Lambda允许把函数作为一个参数,简化了匿名内部类,可以使代码更简洁,提高代码的运行效率(Lambda表达式)
public static void main(String[] args) {
//没有参数类型的Lambda表达式
Arrays.asList(1,2,3).forEach(p -> {
if(p>1){
System.out.println(p);
return ;
}
});
//创建一个线程类
new Thread(() -> System.out.println("this is new Jdk1.8 Lambda") ).start();
final String split=",";
//有参数类型的Lambda表达式
Arrays.asList("1","2","3").forEach((String e) -> {
System.out.println(e+split);
});
//数组进行排序后是输出 Arrays.asList(3,2,3).stream().sorted((p1,p2) -> p1.compareTo(p2)).collect(Collectors.toList()).forEach(( e) -> { System.out.println("this is lambda sort "+ e+split); }); } 以上只是对lambda表达式的简单介绍
4.对方法的引用 (双冒号的方法,对方法的引用)
public static JdKTest createList(Supplier<JdKTest> list){
return list.get();
}
当方法所传参数为Supplier时
final JdKTest jdkTest = JdKTest.createList(JdKTest::new); JdKTest::new表示调用JdKTest的无参构造函数,创建JdKTest对象
public static void methodTest(JdKTest jdkBean){
System.out.println("this is a test");
}
final List< JdKTest > jdkTests = Arrays.asList( jdkTest ); jdkTests.forEach(JdKTest::methodTest); //表示对JdKTest中methodTest方法的调用 5.jdk1.5之后有的注解机制,后被广泛使用,但注解有一个使用限制在相同的位置只可以声明一次注解 而JDK1.8可以引入了重复注解机制,注解可以多次声明
import java.lang.annotation.ElementType; import java.lang.annotation.Repeatable; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import java.util.Arrays;
public class SupplierAnnotations {
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public [@interface](https://my.oschina.net/u/996807) HandleAdapters{
HandleAdapter[] value();
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(HandleAdapters.class)
public @interface HandleAdapter{
String value();
}
@HandleAdapter("this is annotattions test one")
@HandleAdapter("this is annotattions test two")
public interface HandleAdapterTest{};
public static void main(String[] args) {
Arrays.asList(HandleAdapterTest.class.getAnnotationsByType(HandleAdapter.class)).forEach((HandleAdapter e) ->{
System.out.println(e.value());
});
}
} 运行结果 this is annotattions test one this is annotattions test two
多次声明相同的注解主要是@Repeatable(value="A")注解,它注解类标示当前注解类集成于A类注解, 在此处HandleAdapter类注解继承HandleAdapters,而HandleAdapters是HandleAdapter注解的数组 所以HandleAdapterTest拥有多次使用HandleAdapter接口的权利
6.添加了Stream Api,把真正意义上的函数编程引入到了java中,StreamAPI极大程度上的简化了对集合框架的处理,Stream 能够原生的支持并行处理,具体看一下例子
import java.util.Arrays; import java.util.Collection; import java.util.stream.Collectors;
public class StreamTest {
private enum Status{
SLEEP ,WAKE,GETUP
}
@SuppressWarnings("unused")
static final class PeoPle{
private Status status;
private Integer points;
public PeoPle(Status status,Integer points){
this.status =status;
this.points = points;
}
public Status getStatus() {
return status;
}
public Integer getPoints() {
return points;
}
public void setStatus(Status status) {
this.status = status;
}
public void setPoints(Integer points) {
this.points = points;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return String.format("[%s,%d]", status,points);
}
}
public static void main(String[] args) {
final Collection<PeoPle> peopleList= Arrays.asList(
new PeoPle(Status.SLEEP, 50),
new PeoPle(Status.SLEEP, 50),
new PeoPle(Status.WAKE, 60),
new PeoPle(Status.GETUP, 80)
);
//从集合中过滤出正在睡觉的人,并统计出他们的总分数,串行的方式处理
final int retPonits = peopleList.stream().filter(PeoPle -> PeoPle.getStatus().equals(Status.SLEEP))
.mapToInt(PeoPle::getPoints).sum();
System.out.println(retPonits);
//parallel并行的方式处理集合 //当数据量比较大,数据复杂度比较高,硬件比较好的时候可以使用并行流出里集合
final int sumPoints = peopleList.stream().parallel()
.map(people -> people.getPoints()).reduce(0, Integer::sum);
//reduce,0,默认的初始值,sum累加求和
System.out.println("this is sumPonints :"+sumPoints); }}
7.0 PermGen空间被移除了,取而代之的是Metaspace(JEP 122)。JVM选项-XX:PermSize与-XX:MaxPermSize分别被-XX:MetaSpaceSize与-XX:MaxMetaspaceSize所代替