Java1.8新特性实战

public class JDK8_features {
private ArrayList<Integer> list;

@Test
public void test(){
/**
* 1.Lambda表达式
*/
list = new ArrayList<Integer>();
list.add(1); list.add(null);
list.add(3); list.add(null);
list.add(4); list.add(null);

list.forEach(System.out::println);
list.forEach(e -> System.out.println("方式二："+e));

// Java 8之前：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Before Java8, too much code for too little to do");
}
}).start();

//Java 8方式：
new Thread( () -> System.out.println("In Java8, Lambda expression rocks !!") ).start();
}

/**
* 2.Stream函数式操作流元素集合
*/
@Test
public void testStream(){
list = new ArrayList<Integer>();
list.add(1); list.add(null); list.add(1);
list.add(3); list.add(null); list.add(3);
list.add(4); list.add(null);

System.out.println("求和："+list
.stream()//转成Stream
.filter(item -> item!=null)//过滤
.distinct()//去重
.mapToInt(n->n*3)//map操作
.skip(2)//跳过前2个元素
.limit(4)//限制取前4个元素
.peek(System.out::println)//流式处理对象函数
.sum());//
}

/**
* 3.接口新增：默认方法与静态方法
* default 接口默认实现方法是为了让集合类默认实现这些函数式处理，而不用修改现有代码
* （List继承于Iterable<T>，接口默认方法不必须实现default forEach方法）
*/
@Test
public void testDefaultInterface(){
//可以直接使用接口名.静态方法来访问接口中的静态方法
JDK8Interface1.staticMethod();
//接口中的默认方法必须通过它的实现类来调用
new JDK8InterfaceImpl1().defaultMethod();
//多实现类，默认方法重名时必须复写
new JDK8InterfaceImpl2().defaultMethod();
}

public class JDK8InterfaceImpl1 implements JDK8Interface1 {
//实现接口后，因为默认方法不是抽象方法，重写/不重写都成！
public void defaultMethod(){
System.out.println("接口中的默认方法");
}
}

public static class JDK8InterfaceImpl2 implements JDK8Interface1,JDK8Interface2 {
//实现接口后，默认方法名相同，必须复写默认方法
public void defaultMethod() {
//接口的
JDK8Interface1.super.defaultMethod();
System.out.println("实现类复写重名默认方法！！！！");
}

/**
* 4.方法引用,与Lambda表达式联合使用
*/
@Test
public void testMethodReference(){
//构造器引用。语法是Class::new，或者更一般的Class< T >::new，要求构造器方法是没有参数；
final Car car = Car.create( Car::new );
//System.out.print("构造器引用:"+car.toString());
final List< Car > cars = Arrays.asList( car );
//静态方法引用。语法是Class::static_method，要求接受一个Class类型的参数；
cars.forEach( Car::collide );
//任意对象的方法引用。它的语法是Class::method。无参，所有元素调用；
cars.forEach( Car::repair );//特定对象的方法引用，它的语法是instance::method。有参，在某个对象上调用方法，将列表元素作为参数传入；
//final Car police = Car.create( Car::new );
cars.forEach( Car::follow );
}

public static class Car {

public static Car create( final Supplier< Car > supplier ) {
return supplier.get();
}

public static void collide( final Car car ) {
System.out.println( "静态方法引用 " + car.toString() );
}

public void repair() {
System.out.println( "任意对象的方法引用 " + this.toString() );
}

public static void follow( final Car car ) {
System.out.println( "特定对象的方法引用 " + car.toString() );
}
}
}
/**
* 8.新增base64加解密API
*/
@Test
public void testBase64(){
final String text = "我要测试加解密！！";
String pas = Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
System.out.println(pas);

final String decoded = new String(
Base64.getDecoder().decode( pas ), StandardCharsets.UTF_8 );
System.out.println( "解密后="+decoded );
}

/**
* 9.数组并行（parallel）操作
*/
@Test
public void testParallel(){
long[] arr = new long [ 5 ];
//1.给数组随机赋值
Arrays.parallelSetAll( arr,
index -> ThreadLocalRandom.current().nextInt( 1000 ) );
//2.打印出前10个元素
Arrays.stream( arr ).limit( 10 ).forEach(
i -> System.out.print( i + " " ) );
System.out.println();
//3.数组排序
Arrays.parallelSort( arr );
// 4.打印排序后的前10个元素
Arrays.stream( arr ).limit( 10 )
.forEach(i -> System.out.print( i + " " ) );
System.out.println();
}

}