lambda stream 循环_java8的λ（lambda）表达式与Stream API

一、λ(lambda)表达式学习

Java8最值得学习的特性就是Lambda表达式和Stream API，如果有python或者javascript的语言基础，对理解Lambda表达式有很大帮助，因为Java正在将自己变的更高级，更人性化。--------可以这么说lambda表达式其实就是实现SAM接口的语法糖。--引用其他博主

函数式编程：“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法。jdk1.8提供了一个@FunctionalInterface注解来定义函数式接口，如果我们定义的接口不符合函数式的规范便会报错。

@FunctionalInterface

public interface Test {

//只有一个抽象方法

public void helloWorld(String y);

}

//方法体自己搞 -> λ用法

Test t = y -> System.out.println("HelloWorld!!!"+y);

玩一玩，搞一搞

1、线程

大家都爱拿线程举例子：

普通创建一个线程：

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

System.out.println("这是个线程");

}

});

//启动线程

thread.start();

λ用法：

Thread thread1 = new Thread(() -> System.out.println("这是个线程"));

thread1.start();

2、排序(大家都来拿它举例子)

普通玩法：

List list = Arrays.asList(new String[] {"1","103","201","3","204","32","13"});

Collections.sort(list, new Comparator() {

@Override

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

});

System.out.println(list.toString());

//执行结果(附带上一些String排序的小知识)

[1, 103, 13, 201, 204, 3, 32]

λ玩法：

List list = Arrays.asList(new String[] {"1","103","201","3","204","32","13"});

/*Collections.sort(list, new Comparator() {

@Override

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

});*/

Collections.sort(list,(string1,string2) -> string1.compareTo(string2));

System.out.println(list.toString());

//执行结果：

[1, 103, 13, 201, 204, 3, 32]

执行效率分析:

根据排序进行了如下效率分析：

public static void main(String[] args) {

List list = Arrays.asList(new String[] {"1","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13","103","201","3","204","32","13"});

//执行效率分析

for(int i=1;i<=100;i++){

long startTime = System.currentTimeMillis();

for(int j=1;j<=10000;j++){

Collections.sort(list, new Comparator() {

@Override

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

});

}

long endTime = System.currentTimeMillis();

System.out.println("第"+i+"次普通排序执行时间："+(endTime-startTime));

startTime = System.currentTimeMillis();

for(int j=1;j<=10000;j++){

Collections.sort(list,(string1,string2) -> string1.compareTo(string2));

}

endTime = System.currentTimeMillis();

System.out.println("第"+i+"次lambda排序执行时间："+(endTime-startTime));

}

}

执行了100次，取中间20个做分析：

第40次普通排序执行时间：5

第40次lambda排序执行时间：6

第41次普通排序执行时间：6

第41次lambda排序执行时间：5

第42次普通排序执行时间：6

第42次lambda排序执行时间：6

第43次普通排序执行时间：5

第43次lambda排序执行时间：7

第44次普通排序执行时间：6

第44次lambda排序执行时间：6

第45次普通排序执行时间：6

第45次lambda排序执行时间：8

第46次普通排序执行时间：6

第46次lambda排序执行时间：6

第47次普通排序执行时间：11

第47次lambda排序执行时间：7

第48次普通排序执行时间：6

第48次lambda排序执行时间：17

第49次普通排序执行时间：6

第49次lambda排序执行时间：9

第50次普通排序执行时间：7

第50次lambda排序执行时间：7

第51次普通排序执行时间：7

第51次lambda排序执行时间：10

第52次普通排序执行时间：9

第52次lambda排序执行时间：7

第53次普通排序执行时间：8

第53次lambda排序执行时间：7

第54次普通排序执行时间：6

第54次lambda排序执行时间：7

第55次普通排序执行时间：7

第55次lambda排序执行时间：6

第56次普通排序执行时间：8

第56次lambda排序执行时间：8

第57次普通排序执行时间：8

第57次lambda排序执行时间：9

第58次普通排序执行时间：9

第58次lambda排序执行时间：17

第59次普通排序执行时间：8

第59次lambda排序执行时间：10

其中：λ>普通为10次，普通>λ为5次，相等为5次

可能力度不够，将10000调整为100000看看

第40次普通排序执行时间：54

第40次lambda排序执行时间：52

第41次普通排序执行时间：53

第41次lambda排序执行时间：55

第42次普通排序执行时间：52

第42次lambda排序执行时间：52

第43次普通排序执行时间：53

第43次lambda排序执行时间：55

第44次普通排序执行时间：55

第44次lambda排序执行时间：55

第45次普通排序执行时间：58

第45次lambda排序执行时间：59

第46次普通排序执行时间：53

第46次lambda排序执行时间：53

第47次普通排序执行时间：52

第47次lambda排序执行时间：53

第48次普通排序执行时间：57

第48次lambda排序执行时间：55

第49次普通排序执行时间：52

第49次lambda排序执行时间：63

第50次普通排序执行时间：55

第50次lambda排序执行时间：54

第51次普通排序执行时间：51

第51次lambda排序执行时间：54

第52次普通排序执行时间：53

第52次lambda排序执行时间：54

第53次普通排序执行时间：52

第53次lambda排序执行时间：57

第54次普通排序执行时间：61

第54次lambda排序执行时间：60

第55次普通排序执行时间：54

第55次lambda排序执行时间：61

第56次普通排序执行时间：51

第56次lambda排序执行时间：53

第57次普通排序执行时间：54

第57次lambda排序执行时间：59

第58次普通排序执行时间：59

第58次lambda排序执行时间：62

第59次普通排序执行时间：54

第59次lambda排序执行时间：60

将100000调整为1000000看看

第40次普通排序执行时间：564

第40次lambda排序执行时间：586

第41次普通排序执行时间：576

第41次lambda排序执行时间：557

第42次普通排序执行时间：569

第42次lambda排序执行时间：586

第43次普通排序执行时间：599

第43次lambda排序执行时间：582

第44次普通排序执行时间：559

第44次lambda排序执行时间：572

第45次普通排序执行时间：580

第45次lambda排序执行时间：588

第46次普通排序执行时间：578

第46次lambda排序执行时间：572

第47次普通排序执行时间：580

第47次lambda排序执行时间：557

第48次普通排序执行时间：579

第48次lambda排序执行时间：620

第49次普通排序执行时间：582

第49次lambda排序执行时间：606

第50次普通排序执行时间：613

第50次lambda排序执行时间：624

第51次普通排序执行时间：583

第51次lambda排序执行时间：581

第52次普通排序执行时间：653

第52次lambda排序执行时间：683

第53次普通排序执行时间：688

第53次lambda排序执行时间：699

第54次普通排序执行时间：690

第54次lambda排序执行时间：693

第55次普通排序执行时间：573

第55次lambda排序执行时间：707

第56次普通排序执行时间：785

第56次lambda排序执行时间：563

第57次普通排序执行时间：593

第57次lambda排序执行时间：597

第58次普通排序执行时间：561

第58次lambda排序执行时间：568

第59次普通排序执行时间：688

第59次lambda排序执行时间：585

差别其实没有太大

二、Stream (原理很深奥，用法很简单)

同样是，我们先学会骑自行车，再去研究轮子，再去造轮子

Stream是Java 8中的一个大的改进。Stream的功能是，支持集合的各种操作，比如filter, sum, max, min, average, map, reduce等等。

它可以：增强集合操作

拥抱函数式编程

充分利用Lambda

执行效率的提高 - 透明支持多线程集合操作

玩一玩，搞一搞

首先new了一个学生实体类：

public class Student implements Serializable {

private long id;

private String name;

private String sex;

private int age;

private String remore;

//setter And getter方法

}

然后写了一个setListValue方法来给list赋值

public static void setListValue(List list){

for(int i=0;i<1000;i++){

Student student = new Student();

student.setAge(10+(i/100));

student.setId(i);

student.setName("啊"+i);

student.setRemore("这是个"+i);

student.setSex(String.valueOf(i%2));

list.add(student);

}

}

一、使用stream来进行排序

根据id正序正序

//根据id正序

list.stream().sorted(Comparator.comparing(Student::getId)).collect(Collectors.toList());

根据id正序逆序

list.stream().sorted(Comparator.comparing(Student::getId).reversed()).collect(Collectors.toList());

拿出实体复合条件的属性并吧该属性单独放到一个容器中

List oldMan = list.stream().filter(student -> student.getAge() > 18).map(Student::getName).collect(Collectors.toList());

System.out.println(oldMan);

filter做过滤

list.stream().filter(student -> student.getAge()>18).collect(Collectors.toList()).forEach(student -> {

//a="qwer";

student.setName("呦呦呦");

});

forech循环

List addF=new ArrayList<>();

//得到其中所有的Name属性并赋值给addF

addF=list.stream().map(Student::getName).collect(Collectors.toList());

addF.stream().forEach(name ->{

//做一些逻辑

if(name.contains("啊")){

}

});

注意：

forech循环这个里面有点限制，在这个forech循环外命名的变量没有办法在forech循环里面使用，若想使用，必须定义成常量

再更