Java8新特性Stream 和lambda 表达式

Java8新特性Stream 和lambda 表达式

一：Java8新特性
接口默认方法，lambda 表达式 ，函数式接口，Date API 等特性
Stream
作为java8 的新特性，基于lambda表达式，是对集合对象功能的增强，它专注于对集合对象进行各种高效，遍历的聚合操作或者大批量的数据操作
Stream原理：
将要处理的元素看做一种流，流在管道中传输，并且可以在管道的节点上处理，包括过滤，筛选，去重，排序，聚合，元素流在管道中经过中间操作的处理，最后由最终操作得到前面处理的结果
集合有两种方式生成流：
stream() — 为集合创建串行流
parallelStream()—为集合创建并行流

主要针对集合的 去重、筛选、转换、排序、limit 限制返回个数、
skip（删除元素）,删除前n 个元素、reduce 聚合 将集合中的每个元素聚合成一条数据、求最小值 min、anyMatch/allMatch/noneMatch(匹配)
二：案例`

/**
* Created by 10393 on 2020/1/13.
*/
public class Student {

private Long id;
private String name;
private int age;
private String address;

public Student() {
}

public Student(Long id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(id, student.id) &&
Objects.equals(name, student.name) &&
Objects.equals(address, student.address);

}

@Override
public int hashCode() {
return Objects.hash(id, name, age, address);
}
}

```java
/**
* Created by 10393 on 2020/1/13.
*/
public class Test {


public static void main(String[] args) {
Student s1 = new Student(1L, "肖战", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "浙江");
Student s5 = new Student(1L, "肖战", 15, "浙江");
List<Student> stuList = new ArrayList<Student>();

stuList.add(s1);
stuList.add(s2);
stuList.add(s3);
stuList.add(s4);
stuList.add(s5);
//去重
// stuList.stream().distinct().forEach(System.out::println);


List<Student> streamStudents = testFilter(stuList);
streamStudents.forEach(System.out::println);//遍历打印输出
testMap(stuList);
testDistinct1();
testSort1();
testSort2();
testLimit();
testReduce();
testMin();
testMatch();
}

/*
* 集合的筛选
* */
private static List<Student> testFilter(List<Student> students){
//筛选年龄大于15岁的学生
return students.stream().filter(s ->s.getAge()>15).collect(Collectors.toList());
//筛选在浙江省的同学
// return students.stream().filter(s->"浙江".equals(s.getAddress())).collect(Collectors.toList());
}
/*
* 集合转换
* */
private static void testMap(List<Student> students){
List<String> addressess=students.stream().map(s->"住址："+s.getAddress()).collect(Collectors.toList());
addressess.forEach(a->System.out.println(a));
}
/*
* 集合去重（基本类型）
* */
private static void testDistinct1(){
//简单字符串的去重
List<String> list= Arrays.asList("111","222","333","444","111");
list.stream().distinct().forEach(System.out::println);
}
/*
* 集合排序（默认排序）
* */
private static void testSort1(){
List<String> list=Arrays.asList("333","222","111");
list.stream().sorted().forEach(System.out::println);

}

/*
*
* 上面指定排序规则，先按照学生的id进行降序排序，再按照年龄进行降序排序
* */
private static void testSort2(){
Student s1 = new Student(1L, "肖战", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "浙江");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);

students.stream()
.sorted((stu1,stu2) ->Long.compare(stu2.getId(),stu1.getId()))
.sorted((stu1,stu2) ->Integer.compare(stu2.getAge(),stu1.getAge()))
.forEach(System.out::println);
}


/*
* limit 限制返回个数
* */
private static void testLimit(){
List<String> list=Arrays.asList("333","222","111");
list.stream().limit(2).forEach(System.out::println);
}

/*
*
* skip（删除元素）,删除前n 个元素
* */
private static void testSkip(){
List<String> list=Arrays.asList("333","222","111");
list.stream().skip(2).forEach(System.out::println);
}

/*
* reduce 聚合 将集合中的每个元素聚合成一条数据
* */

private static void testReduce(){
List<String> list=Arrays.asList("欢","迎","你");
String appendStr=list.stream().reduce("北京",(a,b)->a+b);
System.out.println("=="+appendStr);
}

/*
* 求最小值 min
* */
private static void testMin(){
Student s1 = new Student(1L, "肖战", 14, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "浙江");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
Student mins= students.stream().min((stu1,stu2)->Integer.compare(stu1.getAge(),stu2.getAge())).get();
System.out.println(mins.toString());
}

/*
* anyMatch/allMatch/noneMatch(匹配)
*
* */
private static void testMatch(){
Student s1 = new Student(1L, "肖战", 15, "浙江");
Student s2 = new Student(2L, "王一博", 15, "湖北");
Student s3 = new Student(3L, "杨紫", 17, "北京");
Student s4 = new Student(4L, "李现", 17, "浙江");
List<Student> students = new ArrayList<>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
Boolean anyMatch=students.stream().anyMatch(s->"湖北".equals(s.getAddress()));
if(anyMatch){
System.out.println("有湖北人");
}
Boolean allMatch=students.stream().allMatch(s->s.getAge()>=15);
if (allMatch){
System.out.println("所有学生都满15岁");
}
Boolean noneMatch=students.stream().noneMatch(s->"杨洋".equals(s.getName()));
if(noneMatch){
System.out.println("没有叫杨洋的同学");
}
}
}