JDK1.8的新特性

以下是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所代替

转载于:https://my.oschina.net/u/3195939/blog/843154