Java Stream流面试题

我是一只代码狗

已于 2024-02-08 19:47:25 修改

阅读量584

点赞数 2

分类专栏： java 文章标签： java

于 2024-02-08 18:41:43 首次发布

原文链接：https://mp.csdn.net/mp_blog/creation/editor?spm=1001.2101.3001.5352

版权

java 专栏收录该内容

279 篇文章 7 订阅

订阅专栏

1.请使用 Java Stream 实现将 List 转换为 Map，key 是字符串的长度，value 是该长度的字符串列表

List<String> list= Arrays.asList("aa","bbb","uuuuuuuu","cccd","dddef","oo");
        //按照字符串的长度进行分组，key是长度，value是相同字符串长度的list集合
        Map<Integer, List<String>> map = list.stream().collect(Collectors.groupingBy(x -> x.length()));
        System.out.println(map);

2.请使用 Java Stream 实现过滤出 List 中所有大于等于 10 的元素

package com.example.demo1.controller;

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

public class Test2 {

    public static void main(String[] args) {
        //请使用 Java Stream 实现过滤出 List 中所有大于等于 10 的元素
        List<Integer> list= Arrays.asList(1,3,5,10,11,45,25);
        //所有大于等于10的 全部放入另一个集合中
        List<Integer>res=list.stream()
                .filter(x->x>=10)
                .collect(Collectors.toList());
        System.out.println(res);
    }
}

3.请使用 Java Stream 合并两个 List，去重，然后升序排列

package com.example.demo1.controller;

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

public class Test3 {
    public static void main(String[] args) {
        //请使用 Java Stream 合并两个 List，去重，然后升序排列
        List<Integer> a= Arrays.asList(1,5,2);
        List<Integer> b= Arrays.asList(2,6,3,10,5);
        List<Integer> concat = Stream.
                //合并2个流
                concat(a.stream(), b.stream())
                //去重
                .distinct()
                //升序
                .sorted()
                //返回List
                .collect(Collectors.toList());
        System.out.println(concat);

    }
}

4.请使用 Java Stream 将 Map 中所有 value 转换为列表

package com.example.demo1.controller;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test4 {
    public static void main(String[] args) {
        //请使用 Java Stream 将 Map 中所有 value 转换为列表
        Map<Integer,Integer> map=new HashMap<>();
        map.put(1,10);
        map.put(2,20);
        map.put(3,30);

        List<Integer> values = map.values()
                .stream().collect(Collectors.toList());
        System.out.println(values);
    }
}

5.请使用 Java Stream 实现对 List 中每个元素进行平方操作

package com.example.demo1.controller;

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

public class Test5 {

    public static void main(String[] args) {
        //请使用 Java Stream 实现对 List 中每个元素进行平方操作
        List<Integer> list= Arrays.asList(1,2,3,4,5);
        List<Integer>res=list.stream().map(x->x*x).collect(Collectors.toList());
        System.out.println(res);
    }
}

6.使用Stream流来完成以下操作

1.生成id为key ,名称为value的map
2. 获取所有评分大于4.5,菜品包含A,B两类的所有商户的评价数之和

package com.example.demo1.controller;

import java.util.List;

public class ShangHu {

    public ShangHu(String id, String name, Integer pingFen, List<String> caiPin, Integer pingJiaShu) {
        this.id = id;
        this.name = name;
        this.pingFen = pingFen;
        this.caiPin = caiPin;
        this.pingJiaShu = pingJiaShu;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getPingFen() {
        return pingFen;
    }

    public void setPingFen(Integer pingFen) {
        this.pingFen = pingFen;
    }

    public List<String> getCaiPin() {
        return caiPin;
    }

    public void setCaiPin(List<String> caiPin) {
        this.caiPin = caiPin;
    }

    public Integer getPingJiaShu() {
        return pingJiaShu;
    }

    public void setPingJiaShu(Integer pingJiaShu) {
        this.pingJiaShu = pingJiaShu;
    }

    private String id;

    //商户
    private String name;

    //评分
    private Integer pingFen;

    //菜品
    private List<String> caiPin;

    //评价数
    private Integer pingJiaShu;

    @Override
    public String toString() {
        return "ShangHu{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", pingFen=" + pingFen +
                ", caiPin=" + caiPin +
                ", pingJiaShu=" + pingJiaShu +
                '}';
    }
}

package com.example.demo1.controller;

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

public class Test6 {
    public static void main(String[] args) {
        //使用Stream流来完成以下操作
        //1.生成id为key ,名称为value的map
        //2. 获取所有评分大于4.5,菜品包含A,B两类的所有商户的评价数之和
        List<ShangHu> list=new ArrayList<>();
        list.add(new ShangHu("1","商户A",5, Arrays.asList("A1","B1"),10));
        list.add(new ShangHu("2","商户B",6, Arrays.asList("A2","B3"),20));
        list.add(new ShangHu("3","商户C",10, Arrays.asList("A4","B5"),1));
        list.add(new ShangHu("4","商户D",3, Arrays.asList("C6","C7"),5));
        list.add(new ShangHu("5","商户E",7, Arrays.asList("D1","E1"),6));

        //第一步解答 转换map tomap需要2个参数 一个是key,一个是value
        Map<String, String> map = list.stream().collect(Collectors
                .toMap(ShangHu::getId, ShangHu::getName));
        System.out.println(map);
        System.out.println("================================");

        //第二步解答
        int sum = list.stream()
                //过滤 评分大于4.5的 只要大于的都查询出来
                .filter(x -> x.getPingFen() > 4.5)
                //过滤菜品 包含A B 开头的 都查询出来
                //先过滤A
                .filter(x -> x.getCaiPin().stream().anyMatch(y -> y.startsWith("A")))
                //然后再过滤B
                .filter(x->x.getCaiPin().stream().anyMatch(y->y.startsWith("B")))
                //对评价数 单独分出来
                .mapToInt(x->x.getPingJiaShu())
                //累加求和
                .sum();
        System.out.println(sum);
    }
}

7.计算List<Integer>中所有偶数的平均值

import java.util.*;
import java.util.stream.Collectors;

public class Test6 {
    public static void main(String[] args) {
        //7.计算List<Integer>中所有偶数的平均值
        List<Integer>list=Arrays.asList(1,2,3,4,5,6);
        double average = list.stream()
                .filter(x -> x % 2 == 0)
                .mapToInt(x -> x).average().orElse(0.0);
        System.out.println(average);
    }
}

8. 将List<String>中的字符串连接成一个单独的字符串，并用逗号分隔

package com.example.demo1.controller;

import java.util.*;
import java.util.stream.Collectors;

public class Test6 {
    public static void main(String[] args) {
        //8. 将List<String>中的字符串连接成一个单独的字符串，并用逗号分隔
        List<String>list=Arrays.asList("a","b","c","d","e");
        String collect = list.stream()
                //把字符串拼接到一起 每个字符之间有个逗号
                .collect(Collectors.joining(","));
        System.out.println(collect);

    }
}

9. 将List<Employee>中的年龄进行排序，并输出排序后的员工列表

package com.example.demo1.controller;

public class Employee{

    private Integer id;

    public Employee(Integer id, Integer age) {
        this.id = id;
        this.age = age;
    }

    private Integer age;

    public Integer getId() {
        return id;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", age=" + age +
                '}';
    }
}

package com.example.demo1.controller;

import java.util.*;
import java.util.stream.Collectors;


public class Test6 {
    public static void main(String[] args) {
        //9. 将List<Employee>中的年龄进行排序，并输出排序后的员工列表
        List<Employee>list=new ArrayList<>();
        list.add(new Employee(1,10));
        list.add(new Employee(2,1));
        list.add(new Employee(3,30));

        List<Employee> collect = list.stream()
                //按照年龄排序
                .sorted(Comparator.comparingInt(x->x.getAge()))
                .collect(Collectors.toList());
        System.out.println(collect);

    }
}

10.将List<Integer>中的元素拼接成一个由逗号分隔的字符串，并去重

package com.example.demo1.controller;

import java.util.*;
import java.util.stream.Collectors;


public class Test6 {
    public static void main(String[] args) {
        //10.将List<Integer>中的元素拼接成一个由逗号分隔的字符串，并去重
        List<Integer>list=Arrays.asList(1,2,3,3,4,5);
        String collect = list.stream()
                //去重复
                .distinct()
                //转换成字符串
                .map(Objects::toString)
                //逗号拼接
                .collect(Collectors.joining(","));
        System.out.println(collect);
    }
}

11.计算List<Double>中的最大值、最小值、总和以及平均值

package com.example.demo1.controller;

import java.util.*;
import java.util.stream.Collectors;


public class Test6 {
    public static void main(String[] args) {
        //11.计算List<Double>中的最大值、最小值、总和以及平均值
        List<Double>list=Arrays.asList(1.0,2.0,3.0,4.0,5.0,6.0);
        double min=list.stream().mapToDouble(x->x).min().getAsDouble();
        double max=list.stream().mapToDouble(x->x).max().getAsDouble();
        double sum=list.stream().mapToDouble(x->x).sum();
        double avg=list.stream().mapToDouble(x->x).average().getAsDouble();
        System.out.println(min);
        System.out.println(max);
        System.out.println(sum);
        System.out.println(avg);
    }
}