函数式编程：stream

参考：

forEach 循环

@Test
public void forEach(){
    // 你不鸟我,我也不鸟你
    List<String> list = Arrays.asList("you", "don't", "bird", "me", ",",
                                       "I", "don't", "bird", "you");

    // 方式一：JDK1.8之前的循环方式
    for (String item: list) {
        System.out.println(item);
    }

    // 方式二：使用Stream的forEach方法
    // void forEach(Consumer<? super T> action)
    list.stream().forEach(item -> System.out.println(item));

    // 方式三：方式二的简化方式
    // 由于方法引用也属于函数式接口，所以方式二Lambda表达式也可以使用方法引用来代替
    // 此种方式就是方式一、方式二的简写形式
    list.stream().forEach(System.out::println);
}

View Code

filter（筛选）

示例1

package stream;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.util.Objects;

@Data
@AllArgsConstructor
public class Student {
    private Long id;
    private String name;
    private int age;
    private String 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);
    }
}

View Code

package stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    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, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        List<Student> streamStudents = testFilter(students);
        streamStudents.forEach(System.out::println);
    }
    /**
     * 集合的筛选
     * @param students
     * @return
     */
    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());
    }
}

View Code

map 映射

map就是将对应的元素按照给定的方法进行转换。

package stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    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, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        testMap(students);
    }

    /**
     * 集合转换
     * @param students
     * @return
     */
    private static void testMap(List<Student> students) {
        //在地址前面加上部分信息，只获取地址输出
        List<String> addresses = students.stream().map(s ->"住址:"+s.getAddress()).collect(Collectors.toList());
        addresses.forEach(a ->System.out.println(a));
    }
}

View Code

@Test
public void map(){
    List<String> list = Arrays.asList("how", "are", "you", "how", "old", "are", "you", "?");
    // <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    list.stream().map(item -> item.toUpperCase()).forEach(System.out::println);
}

View Code

distinct(去重)

package stream;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testDistinct1();
    }
    /**
     * 集合去重（基本类型）
     */
    private static void testDistinct1() {
        //简单字符串的去重
        List<String> list = Arrays.asList("111","222","333","111","222");
        list.stream().distinct().forEach(System.out::println);
    }
}

View Code

package stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {

        testDistinct2();
    }
    /**
     * 集合去重（引用对象）
     */
    private static void testDistinct2() {
        //引用对象的去重，引用对象要实现hashCode和equal方法，否则去重无效
        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> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        students.add(s5);
        students.stream().distinct().forEach(System.out::println);
    }
}

View Code

可以看出，两个重复的“肖战”同学进行了去重，这不仅因为使用了distinct()方法，而且因为Student对象重写了equals和hashCode()方法，否则去重是无效的。

sorted(排序)

package stream;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testSort1();
    }
    /**
     * 集合排序（默认排序）
     */
    private static void testSort1() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().sorted().forEach(System.out::println);
    }
}

View Code

package stream;
import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testSort2();
    }
    /**
     * 集合排序（指定排序规则）
     */
    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);
    }
}

View Code

上面指定排序规则，先按照学生的id进行降序排序，再按照年龄进行降序排序

limit（限制返回个数）

package stream;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testLimit();
    }
    /**
     * 集合limit，返回前几个元素
     */
    private static void testLimit() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().limit(2).forEach(System.out::println);
    }
}

View Code

skip(删除元素)

package stream;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testSkip();
    }
    /**
     * 集合skip，删除前n个元素
     */
    private static void testSkip() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().skip(2).forEach(System.out::println);
    }
}

View Code

reduce(聚合)

package stream;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testReduce();
    }
    /**
     * 集合reduce,将集合中每个元素聚合成一条数据
     */
    private static void testReduce() {
        List<String> list = Arrays.asList("欢","迎","你");
        String appendStr = list.stream().reduce("北京",(a,b) -> a+b);
        System.out.println(appendStr);
    }
}

View Code

min(求最小值)

package stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testMin();
    }

    /**
     * 求集合中元素的最小值
     */
    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());
    }
}

View Code

anyMatch allMatch noneMatch（匹配）

package stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String [] args) {
        testMatch();
    }

    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("没有叫杨洋的同学");
        }
    }
}

View Code

anyMatch：Stream 中任意一个元素符合传入的 predicate，返回 true

allMatch：Stream 中全部元素符合传入的 predicate，返回 true

noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

count 总数量

@Test
public void count(){
    Stream<String> stream = Stream.of("know", "is", "know", "noknow", "is", "noknow");
    long count = stream.count();
    System.out.println(count);
}

View Code

collect

@Test
public void collect(){
    List<String> list = Arrays.asList("a", "b", "c", "d", "e");
    // Stream -> Collection
    List<String> collect = list.stream().collect(Collectors.toList());

    // Stream -> Object[]
    Object[] objects = list.stream().toArray();
}

View Code

concat

@Test
public void concat(){
    List<String> list = Arrays.asList("a", "b");
    List<String> list2 = Arrays.asList("c", "d");
    Stream<String> concatStream = Stream.concat(list.stream(), list2.stream());
    concatStream.forEach(System.out::println);
}

View Code

findFirst、findAny

@Test
public void findFirst(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    String value = stream.findFirst().get();
    System.out.println(value);
}

@Test
public void findAny(){
    Stream<String> stream = Stream.of("you", "give", "me", "stop");
    String value2 = stream.findAny().get();
    System.out.println(value2);
}

View Code

posted @ 2020-04-08 22:21 弱水三千12138 阅读(336) 评论(0) 收藏举报

刷新页面返回顶部

弱水三千12138

格言：纸上得来终觉浅 绝知此事要躬行

函数式编程：stream

forEach 循环

filter（筛选）

map 映射

distinct(去重)

sorted(排序)

limit（限制返回个数）

skip(删除元素)

reduce(聚合)

min(求最小值)

anyMatch allMatch noneMatch（匹配）

count 总数量

collect

concat

findFirst、findAny

格言：纸上得来终觉浅绝知此事要躬行