Java基础第8天总结（map遍历、Stream流）

原创于 2025-09-01 21:30:22 发布 · 273 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

java基础专栏收录该内容

11 篇文章

订阅专栏

选中一部分代码，然后CTRL+ALT+T，可以在外面套上while循环,try..catch之类的
小案例：电影信息管理模块：用户可以上架、查询、下架、下架某个主演参演的电影

package Demo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Movie {
    private String name;
    private double score;
    private String actor;
    private double price;
}

package Demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class MovieService {
    private static List< Movie> movies = new ArrayList<>();
    private static Scanner sc = new Scanner(System.in);
    public void start() {
        while (true) {//选中一块区域，然后CTRL+ALT+T
            System.out.println("===电影信息操作系统===");
            System.out.println("1、上架");
            System.out.println("2、下架");
            System.out.println("3、查询某个电影");
            System.out.println("4、封杀某个明星");
            System.out.println("5、退出");
            System.out.println("请您输入操作命令：");
            int command = sc.nextInt();
            switch (command) {
                case 1:
                    addMovie();
                    break;
                case 2:
                    //removeMovie();
                    break;
                case 3:
                    searchMovie();
                    break;
                case 4:
                    banStar();
                    break;
                case 5:
                    System.out.println("退出成功！！");
                    return;
                default:
                    System.out.println("输入的命令有误！");
            }
        }
    }

    private void banStar() {
        System.out.println("====封杀明星====");
        System.out.println("请输入要封杀的明星：");
        String star = sc.next();
        for (int i = 0; i < movies.size(); i++) {
            Movie movie = movies.get(i);
            if (movie.getActor().contains(star)) {
                movies.remove(movie);
                System.out.println("封杀成功！");
                i--;
            }
        }
    }

    private void searchMovie() {
        System.out.println("====查询电影====");
        System.out.println("请输入要查询的电影名称：");
        String name = sc.next();
        Movie movie = searchMovieByName(name);
        if (movie != null) {
            System.out.println(movie);
        }else{
            System.out.println("没有找到该电影！");
        }
    }
    //根据电影名字查询电影对象返回
    public Movie searchMovieByName(String name) {
        for (Movie movie : movies) {
            if (movie.getName().equals(name)) {
                return movie;
            }
        }
        return null;
    }
    private void addMovie() {
        System.out.println("====上架电影====");
        //1、创建电影对象，封装这部电影信息
        Movie movie = new Movie();
        //2、给电影对象注入数据
        System.out.println("请输入电影名称：");
        movie.setName(sc.next());
        System.out.println("请输入电影评分：");
        movie.setScore(sc.nextDouble());
        System.out.println("请输入主演：");
        movie.setActor(sc.next());
        System.out.println("请输入价格：");
        movie.setPrice(sc.nextDouble());
        //3、将电影对象添加到集合中
        movies.add(movie);
        System.out.println("上架成功");
    }
}

package Demo;

public class Test {
    public static void main(String[] args) {
        //1、创建电影对象：定义电影类
        //2、创建一个电影操作对象：专门负责对电影数据进行业务处理
        MovieService movieService = new MovieService();
        movieService.start();
    }
}

Map集合的三种遍历方式：

package Demo;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("张三", 18);
        map.put("李四", 19);
        map.put("王五", 20);
        System.out.println(map);
        System.out.println("------------------");
        //1、将map集合的全部键放到set集合中
        Set<String> keys = map.keySet();
        for (String key : keys) {
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("------------------");
        //2、把map集合转换成set集合，里面的元素类型都是键值对类型（Map.Entry<String,Integer>）
        Set<Map.Entry<String, Integer>> entries = map.entrySet();//快捷键：map.entrySet().var+回车
        for (Map.Entry<String, Integer> entry : entries) {//快捷键：entries.for+回车
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        System.out.println("------------------");
        //3、直接调用map集合的forEach方法遍历
        map.forEach((key,value)->{
            System.out.println(key + "=" + value);
        });
    }
}

Stream流
小案例：找到以“张”开头，并且是三个字的元素，存储到一个新集合

package Demo;

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

public class StreamDemo {
    public static void main(String[] args) {
        //找到以“张”开头，并且是三个字的元素，存储到一个新集合
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张小四");
        //法一：传统方法：找出姓张，名字三个字的，存入新集合中
        List<String> newList = new ArrayList<>();
        for (String name : list) {
            if (name.startsWith("张") && name.length() == 3) {
                newList.add(name);
            }
        }
        System.out.println(newList);
        System.out.println("-----------------");
        //法二：使用Stream流
        List<String> newList2 = list.stream().filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .collect(Collectors.toList());
        System.out.println(newList2);
    }
}

获取Stream流的方式

package Demo;

import java.util.*;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
       //获取Stream流的方式
       //1、获取集合的Stream流：调用集合提供的stream（）方法
        Collection<String> list = new ArrayList<>();
        Stream<String> s1 = list.stream();//快捷键:list.stream().var+回车

        //2、Map集合，怎么去拿Stream流
        Map<String,Integer> map = new HashMap<>();
        //获取键流
        Stream<String> s2 = map.keySet().stream();
        //获取值流
        Stream<Integer> s3 = map.values().stream();
        //获取键值对流
        Stream<Map.Entry<String,Integer>> s4 = map.entrySet().stream();

        //3、数组，获取数组的Stream流
        String[] arr = {"张三","李四","王五"};
        Stream<String> s5 = Arrays.stream(arr);
        Stream<String> s6 = Stream.of(arr);
        Stream<String> s7 = Stream.of("张三","李四","王五");
    }
}

Stream提供的常用的中间方法，对流上的数据进行处理（返回新流，支持链式编程）

package Demo;

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

public class StreamDemo {
    public static void main(String[] args) {
       //掌握Stream提供的常用的中间方法，对流上的数据进行处理（返回新流，支持链式编程）
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张小四");

        //1、过滤方法
        list.stream().filter(s -> s.startsWith("张")&&s.length()==3)
                .forEach(s -> System.out.println(s));
        System.out.println("--------------------------------");
        //2、排序方法
        List<Double> scores = new ArrayList<>();
        scores.add(99.9);
        scores.add(66.6);
        scores.add(66.6);
        scores.add(77.7);
        scores.stream().sorted().forEach(s -> System.out.println(s));//默认升序
        System.out.println("--------------------------------");
        scores.stream().sorted((s1,s2) -> Double.compare(s2,s1)).forEach(s -> System.out.println(s));//降序
        System.out.println("--------------------------------");
        scores.stream().sorted((s1,s2) -> Double.compare(s2,s1)).limit(2).forEach(s -> System.out.println(s));//降序并且取前两个
        System.out.println("--------------------------------");
        scores.stream().sorted((s1,s2) -> Double.compare(s2,s1)).skip(2).forEach(s -> System.out.println(s));//降序并且跳过前两个
        System.out.println("--------------------------------");
        scores.stream().sorted((s1,s2) -> Double.compare(s2,s1)).distinct().forEach(s -> System.out.println(s));//去重
        System.out.println("--------------------------------");
        //映射/加工方法：把流上原来的数据拿出来变成新数据又放到流上去
        scores.stream().map(s -> "加十分后"+(s+10)).forEach(s -> System.out.println(s));
        System.out.println("--------------------------------");
        //合并流：
        Stream<String> s1 = Stream.of("张无忌", "周芷若", "赵敏", "张强", "张三丰", "张小四");
        Stream<Integer> s2 = Stream.of(1,2,3);
        Stream<Object> s3 = Stream.concat(s1, s2);
        System.out.println(s3.count());
    }
}

Stream流的终结方法

package Demo;

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

public class StreamDemo {
    public static void main(String[] args) {
        List<Teacher> teachers = new ArrayList<>();
        teachers.add(new Teacher("张三", 18, 5000));
        teachers.add(new Teacher("李四", 19, 6000));
        teachers.add(new Teacher("王五", 20, 7000));
        teachers.stream().filter(t -> t.getSalary() > 5000).forEach(System.out::println);//遍历输出
        System.out.println("--------------------------------");
        long count = teachers.stream().filter(t -> t.getSalary() > 5000).count();//统计个数
        System.out.println(count);
        System.out.println("--------------------------------");
        Optional<Teacher> max = teachers.stream().max((t1, t2) -> Integer.compare(t1.getSalary(), t2.getSalary()));
        System.out.println(max.get());//获取最大值
        System.out.println("--------------------------------");
        Optional<Teacher> min = teachers.stream().min((t1, t2) -> Integer.compare(t1.getSalary(), t2.getSalary()));
        System.out.println(min.get());//获取最小值
        System.out.println("--------------------------------");
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张小四");
        //收集到list集合
        List<String> newList = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toList());
        //收集到set集合
        Set<String> newSet = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toSet());
        //收集到数组
        String[] newArray = list.stream().filter(s -> s.startsWith("张")).toArray(String[]::new);
        //toArray() 方法默认会返回 Object[] 类型的数组，而通过 String[]::new 可以直接得到 String[] 类型的数组
        //收集到map集合
        Map<String, Integer> newMap = list.stream().filter(s -> s.startsWith("张")).collect(Collectors.toMap(s -> s, s -> s.length()));
    }
}