JAVA的JDK1.8新特性

JDK1.8的新特性

匿名类

接口新特性

Lambda(λ)表达式;

数据流:深入到JDK源码中写代码;Spark增强版的数据流

时间的新特性

1.匿名类

多线程:Runnable接口

1 先写一个类,实现runnable接口,重写run方法

2 在main方法中new Thread(runnable).start();

标准:

1 得有接口,接口里面的方法比较少;

2 大括号就是类体,木有类的名字,所以叫做匿名类

** 用在哪里面:**

1 确定类体只能使用一次代码;run方法不能重复使用

2 好处:省去了一个MyRunnable的类

2.接口

属性:public static final ;写不写都一样;接口.属性就可以使用;

方法:全部是抽象的:public abstract void

需求:标准

所有实现类的方法都是一样的(得new对象;在方法上面加上default

接口里面的方法也可是静态的;(得类名.方法名);

3.lambda表达式

语法超级简单:—python,scala;

相当于匿名函数(方法);方法的参数居然可是一个方法;js的类型就有Function;特殊像匿名类

写法

(参数,参数2,参数3…) ->

{

方法体;

}

所有的参数类型可以省略,会推算出变量的类型

如果参数只有一个,小括号可以省略

如果方法体只有一行,大括号可以省略;

E(变量名) -> 方法体只有一行

哪些地方可以写Lambda表达式

必须接口中有只有一个抽象的方法

某个方法的参数是此接口;

参数列表和方法体,返回值如何对应(参照的是接口中抽象方法)

接口的注解:@override,@Test;如果接口的注解是@FunctionalInterface,优先级最高,肯定可以写lambda表达式;

4 方法引用

OverrideImp::new = new OverrideImp()

: 表示调用方法;左边是类名或者对象;右边是方法名;木有参数

只能调用无参的

5.数据流

Stream:

1 返回值是最终的结果;所有的操作马上执行;action

2 返回值还是流(他自己),链式编程;所有的操作都不会执行;(懒执行);transformation

主要方法:

1 Parallel:平行;单线程,调用此方法会变成多线程;利用CPU硬件的核数全部计算

2 Filter:不是最终的;(transformation);算子(方法);过滤数据使用的

3 Map:transformation算子,从一个值变成另外一个值;

4 flatMap:transformation算子,

5 Distinct:transformation去掉;

6 Sorted:排序;transformation

7 Limit:transformation取前几条记录;每页多少条

8 Skip:transformation跳过;从第几条开始,跳过前面的第N条;

9 forEach:action;循环

10 toArray:action;数组

11 Reduce:减少;(合并);action

12 Collect:action;把每一个线程算完的结果汇总一下

13 min和max(action)

14 Count:action;总条数

15 findFirst,findAny;

16 Of:把一个参数放到数据流里面

方法的测试代码

package com.carlinfo.news.stream;

import java.util.Arrays;
import Java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.junit.Test;

/**

流式的操作

流式操作和Spark的关系特别像:

javase中的容器;http://commons.apache.org/proper/commons-collections/

@author WangshMac
*/
public class StreamMain
{
private List alList = Arrays.asList(“test”, “text”, “b”,“b”, “c”, “d”);

/**

filter

检查一个,公布一个结果;并不是将所有的全部检查完以后,再公布结果

action类算子,一旦执行,stream自己关闭

如果你觉得效率特别低

paralel:一定要写到最前面;
/
@Test
public void filter()
{
/ 流:Stream /
Stream stream = alList.stream() ;
/----Java原生的编程----/
/ transformation算子:

懒执行:
transformation要想执行,后面紧跟一个action算子;链式编程
/
stream = stream.parallel().filter(new Predicate()
{
@Override
public boolean test(String t)
{
System.out.println(t + “Predicate”);
return true;
}
});
/ 循环:匿名类
Action类算子
方法是一个接口
/
stream.forEach(new Consumer()
{
@Override
public void accept(String t)
{
System.out.println(t + “java接口”);
}
});
/ 关闭 */
stream.close();
/*----Lambda的编程----

~先看方法的参数是哪个接口
~再看接口中的抽象方法(只有一个)
~对着接口中抽象的方法:只关心,形参和返回值
链式编程
*/
stream = alList.stream() ;
stream.filter( e ->
{
System.out.println("=lambda=检查==" + e);
/*return true ; */
boolean flag = e.indexOf(“te”) != -1 ;
return flag ;
}).forEach((String c) ->
{
System.out.println(“lambda=循环” + c);
});
}
/**

map的相关方法
/
@Test
public void map()
{
/ 获取一个流 /
Stream stream = this.alList.stream() ;
/----java版本----/
/

T:输入参数
$:输出结果
/
Stream streamInt = stream.map(new Function<String, Integer>()
{
@Override
public Integer apply(String t)
{
System.out.println(t + “map=”);
/ 写死了 /
return 1;
}
}).distinct();
/ 去重 */
/* 循环 */
streamInt.forEach(new Consumer()
{
@Override
public void accept(Integer t)
{
System.out.println(t + “foreach=”);
}
});

//System.out.println(streamInt.count() + “=count”);
/----lambda表达式–入-----/
/**

lambda大部分情况下会自动判断类型,有些判断不了;
/
stream = alList.stream() ;
/ map操作 /
streamInt = stream.map( e ->
{
System.out.println(e + “maplambda=”);
return 1 ;
}).distinct();
/streamInt.forEach(e ->
{
System.out.println(e + “foreach=lambda”);
});/
/ 计算总条数 */
System.out.println(streamInt.count() + “=count”);
}
/**

压平;平板

和map特别像
/
@Test
public void flatMap()
{
Stream stream = this.alList.stream() ;
/ flatmap

返回值再也不是Stream了,而是Stream
/
List resultList = stream.flatMap(new Function<String, Stream>()
{
@Override
public Stream apply(String t)
{
System.out.println(“flatmap java” + t);
/ map的返回值是Integer,
* flatMap的返回值是Stream /
return Stream.of(t);
}
}).distinct().collect(Collectors.toList());
/ :distinct:去重
collect:收集;参数的类型,看API文档 */
System.out.println(“结果>” + resultList);
/* lambda表达式, */
}

/**

其它的方法
/
@Test
public void others()
{
Stream stream = this.alList.stream() ;
/ action算子 /
//stream
/ 排序
默认升序,
可以指定比较器,倒序 /
//.sorted((e1,e2) -> -e1.compareTo(e2))
/ 跳过 /
//.skip(3)
/ 每页多少条 */
//.limit(2)
//.forEach(e -> System.out.println("====" + e));
/* 取第一个 /
Optional optional = stream
/ 取第一个 /
//.findFirst();
/ 取任何一个 /
//.findAny();
/ 取最小的 */
.min((e1,e2) -> e1.compareTo(e2));
System.out.println("–findFirst-----" + optional.get()) ;
}
}

作者：yupang

余胖笔记 站点 QQ交谈