一、lambda表达式处理stream操作

lambda表达式与stream的组合简化了集合数据处理的过程。

1.List转set

set集合的特点是去重

将List集合转换为set集合就是去除重复元素即可，这里就利用stream流。

package secondday.homework;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
​
public class lambda {
    //list转为set集合
    public static void main(String args[]){
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
​
        Set<Integer> set=list.stream().collect(Collectors.toSet());
        System.out.println(set);
    }
}

通过stream()方法创建流，再使用collect(Collectors.toSet())将流中的元素收集到Set中，set的特性会自动去掉重复元素

2.List转为Map

某个属性为键构建map，map是键值对的形式，key-value

class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public int getAge() {
        return age;
    }
​
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class lambda {
    public static void main(String args[]){
        List<Person> personList=new ArrayList<>();
        personList.add(new Person("bai",22));
        personList.add(new Person("bob",23));
        //Person::getName是键   p->p是值 转换为map集合键值对的形式
        Map<String,Person> personMap=personList.stream().collect(Collectors.toMap(Person::getName,p->p));
        System.out.println(personMap);
    }
}

Collectors.toMap()的第一个参数是指定键的提取方式，第二个p->p表示值就是对象本身

3.Map转List

把map转为list,对键值对进行统一的处理，通过entry进行了统一的处理

public class lambda {
    public static void main(String args[]){
        //map转为list集合
        Map<Integer,String> map=new HashMap<>();
        map.put(1,"bai");
        map.put(2,"xiao");
        map.put(3,"min");
        //将map的键值对放在了entry里面组成了一个
        List<Map.Entry<Integer,String>> list=map.entrySet().stream().collect(Collectors.toList());
        System.out.println(list);
    }
}

4.过滤

筛选符合条件组合

从List中筛选出偶数 此时我们会借助.filter方法：

public class lambda {
    public static void main(String args[]){
    List<Integer> list=new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    List<Integer> list1=list.stream().filter(num->num%2==0).collect(Collectors.toList());
        System.out.println(list1);
    }
}

5.求和

对list进行求和，通过stream流进行求和

public class lambda {
    public static void main(String args[]){
    List<Integer> list=new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    //mapToInt(Integer::intValue)将Integer转化为int形式然后再相加
    int num=list.stream().mapToInt(Integer::intValue).sum();
        System.out.println(num);
    }
}

6.分组

对Person对象按照年龄分组：流中的collect中的collectors中的groupingby

class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
​
    public String getName() {
        return name;
    }
​
    public int getAge() {
        return age;
    }
​
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class lambda {
    public static void main(String args[]) {
        List<Person> list=new ArrayList<>();
        list.add(new Person("nihao",12));
        list.add(new Person("en",30));
        list.add(new Person("xiao",30));
        //分组是流里面的groupingBy然后里面是根据年龄分的组
        Map<Integer,List<Person>> map=list.stream().collect(Collectors.groupingBy(Person::getAge));
        System.out.println(map);
​
    }
}

7.map与reduce：元素转换与积累

map元素映射转换，将list中的元素转为大写 map

public class lambda {
    public static void main(String args[]) {
        List<String> list=new ArrayList<>();
        list.add("hello");
        list.add("wo");
        //是采用map元素映射做的大小写的转换
        List<String> list1=list.stream().map(String::toUpperCase).collect(Collectors.toList());
        System.out.println(list1);
    }
}

8.reduce元素积累操作

reduce是将流中的元素组合成一个单个的值，并通过指定的二元操作符来不断地将元素进行合并和积累

其中reduce的返回类型是Optional，Optional是防止返回为空

public class lambda {
    public static void main(String args[]) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Optional<Integer> list1=list.stream().reduce((a, b)->a+b);
        System.out.println(list1);
    }
}

查找最大值和最小值

public class lambda {
    public static void main(String args[]) {
        List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        Optional<Integer> list1=list.stream().reduce((a, b)->a>b?a:b);
        System.out.println(list1);
    }
}

连接所有的字符串

public class lambda {
    public static void main(String args[]) {
        List<String> list=new ArrayList<>();
        list.add("h");
        list.add("e");
        list.add("l");
        list.add("l");
        Optional<String> list1=list.stream().reduce((a, b)->a+b);
        System.out.println(list1);
    }
}