集合基础（二）

最新推荐文章于 2024-05-18 16:42:38 发布

大面积秃头

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量71

点赞数

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

本文链接：https://blog.csdn.net/wode39/article/details/127647594

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

双列集合Map

Map是一个接口
如何创建Map对象
- 多态的方式
- 具体实现类HashMap
Map集合的常用功能
- 添加元素
  - V put(K key,V value)
- 根据键值对删除
- 移除所有键值对元素
- 判断集合是否包含指定的键
- 判断是否包含指定的值
- 判断集合是否为空
- 集合的长度
Map集合的获取功能
- 根据键获取值
- 获取所有键的集合
- 获取所有值得集合
- 获取所有键值对对象的集合
Map集合的遍历方式
- 使用KeySet获取所有的键，再使用增强for
- 使用EntrySet获取所有键值对，再使用for循环

Stream流

Stream流的思想方法

获取方法
- 获取对象，将其置于流水线上
中间方法
- 对流水线上的数据进行操作一次操作完毕，还可以进行其他操作
终结方法
- 一个Stream流只有一个终结方法，是流水线最后一个操作

生成Stream流的方式

Collection体系集合
- 使用默认方法Stream（）生成流
Map集合体系
- 把Map转成Set集合，简介生成流
数组
- 通过Arrays静态方法生成流
同种类型的多个数据
- 通过接口的静态方法of( T value)生成流

练习

知识点

Map集合基础，练习

Map存储数据的特点是什么？

Map存数据是以键值对的形式，可以存储双列。
描述HashMap的底层实现原理(jdk 8版)？

二叉树，数组，红黑树
Map中常用实现类有哪些？各自有什么特点？

TreeMap

HashMap

如何遍历Map中的key-value对，代码实现(至少2种)

方法一：
Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key= entry.getKey();
            String value=entry.getValue();
            System.out.println(key+","+value);

        }
方法二：
    Set<Integer> it = stations.keySet();
        for (Integer key : it) {
            String value=stations.get(key);
            System.out.println(key+" "+value);
        }

Collection和Collections的区别？

Collection: 是集合类的上层接口。本身是一个Interface,里面包含了一些集合的基本操作。 Collection接口时Set接口和List接口的父接口

Collections 是一个包装类，Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许，一些 collection 是有序的，而另一些则是无序的
Map接口中的常用方法有哪些？

put() remove() keySet() entrySet() replace()…

（Map）已知某学校的教学课程内容安排如下：
前者是老师，后者是老师所教的课程：
		("Tom", "CoreJava");
        ("John", "Oracle");
        ("Susan", "Oracle");
        ("Jerry", "JDBC");
        ("Jim", "Unix");
        ("Kevin", "JSP");
        ("Lucy", "JSP");
        
完成下列要求：
1） 使用一个Map，以老师的名字作为键，以老师教授的课程名作为值，表示上述课程安排。
2） 增加了一位新老师Allen 教JDBC
3） Lucy 改为教CoreJava
4） 遍历Map，输出所有的老师及老师教授的课程(用Set<Map.Entry<String,String>>、Set<String> get(key)都可)
5） 利用Map，输出所有教JSP的老师。

public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
       map.put("Tom", "CoreJava");
       map.put("John", "Oracle");
        map.put("Susan", "Oracle");
        map.put("Jerry", "JDBC");
        map.put("Jim", "Unix");
        map.put("Kevin", "JSP");
        map.put("Lucy", "JSP");
        map.put("Allen","JDBC");
        //修改值,key相同,value覆盖
        map.put("lucy","CoreJava");
        System.out.println(map);

        //遍历输出
        //获取所有键的集合
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键，用增强for实现
        for (String key : keySet) {
            String value= map.get(key);
            System.out.println(key+","+value);
        }
        System.out.println("+++++++++++++++++++++++++++++++");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key= entry.getKey();
            String value=entry.getValue();
            if (value=="JSP"){
                System.out.println("JSP老师："+key);
            }

        }

模拟斗地主洗牌发牌（争取根据自己的思路在写一遍）
/*
1、分析：首先应准备牌：完成数字与纸牌的映射关系：使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系。

     洗牌：通过数字完成洗牌发牌（借助工具类）

     发牌：将每个人以及底牌设计,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌给3个玩家。存放的过程中要求数字大小与斗地主规则的大小对应排序。将代表不同纸牌的数字分配给不同的玩家与底牌。

     看牌：通过Map集合找到对应字符展示。通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。*/
    
   
    public static void main(String[] args) {
        HashMap<Integer,String> poker=new HashMap<Integer,String>();
        String [] images={"♥","♠","♣","♦"};
        String [] logos={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        ArrayList<Integer> indexs=new ArrayList<>();

        int index=0;
        //制作牌面
        for (String image : images) {
            for (String logo : logos) {
                poker.put(index,image+logo);
                indexs.add(index);
                index++;
            }
        }
        //制作大小王
        poker.put(index,"大王");
        indexs.add(index++);

        poker.put(index,"小王");
        indexs.add(index);

        //创建三个人
        TreeSet<Integer> jia=new TreeSet<>();
        TreeSet<Integer> lin=new TreeSet<>();
        TreeSet<Integer> xue=new TreeSet<>();
        TreeSet<Integer> baseFaker=new TreeSet<>();

        //洗牌
        Collections.shuffle(indexs);

        for (int i = 0; i <indexs.size(); i++) {
            if (i>indexs.size()-3){
                baseFaker.add(indexs.get(i));
            } else if (i%3==0) {
                jia.add(indexs.get(i));
            }else if (i%3==1) {
                lin.add(indexs.get(i));
            }else if (i%3==2) {
                xue.add(indexs.get(i));
            }
        }


        //三人看牌
        lookPoker("贾宝玉",jia,poker);
        lookPoker("林黛玉",lin,poker);
        lookPoker("薛宝钗",xue,poker);
        lookPoker("底牌",baseFaker,poker);
    }

    public static void lookPoker(String name, TreeSet<Integer> indexs,HashMap<Integer,String> poker){
        System.out.println(name+"的牌为：");
        for (Integer index : indexs) {
            System.out.print(poker.get(index)+" ");
        }
        System.out.println();
    }

【1】将以下车站对应关系的数据存储到map集合中，
key：表示站编号，value：表示站名，
并遍历打印(可以不按顺序打印)：
------------------------------------    
     站编号和站名对应关系如下：
    1 朱辛庄
	2 育知路
	3 平西府
	4 回龙观东大街
	5 霍营
	6 育新
	7 西小口
	8 永泰庄
	9 林萃桥
	10 森林公园南门
	11 奥林匹克公园
	12 奥体中心
	13 北土城
	14 安华桥
	15 安德里北街
	16 鼓楼大街
	17 什刹海
	18 南锣鼓巷
    19 中国美术馆   
------------------------------------    

【2】计算地铁票价规则：
总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶；

需要对键盘录入的上车站
和到达站进行判断，如果没有该站，
提示重新输入，直到站名存在为止
每站需要2分钟

示范如下：
-------------------------------------
请输入上车站：
    流沙河
     
    您输入的上车站：流沙河站不存在，请重新输入上车站：
    骑龙
    
    您输入的上车站：骑龙站不存在，请重新输入上车站：
    朱辛庄
    您以确定在朱辛庄上站！
    
    请输入到达站：
    沙河
    
    您输入的到达站：沙河站不存在，请重新输入到达站：
    西二旗
     
    您输入的到达站：西二旗站不存在，请重新输入到达站：
    西小口
    您以确定在朱辛庄下站！
    
    从朱辛庄到西小口共经过6站收费6元，大约需要12分钟
-----------------------------------------------

public static void main(String[] args) {
        TreeMap<Integer,String> stations=new TreeMap<>();
        int index=1;
        TreeSet<String> addrs=new TreeSet<>();
        String [] addresses={"朱辛庄", "育知路", "平西府", "回龙观东大街", "霍营", "育新", "西小口", "永泰庄", "林萃桥",
                "森林公园南门", "奥林匹克公园", "奥体中心", "北土城", "安华桥", "安德里北街", "鼓楼大街", "什刹海",
                "南锣鼓巷", "中国美术馆"};
        for (String address : addresses) {
            stations.put(index,address);
            index++;
        }

        //定义站名
        int startIndex=0;
        int endIndex=0;
        int passStation=0;

        //输入站名
        boolean flag=true;
        while(flag){
            System.out.println("请输入上车站名：");
            Scanner sc=new Scanner(System.in);
            String startStation =sc.nextLine();
            if (isExist(startStation,stations)){
                System.out.println("您已确定上车！");
                while(true){
                    System.out.println("请输入目的站：");
                    String endStation=sc.nextLine();
                    if (isExist(endStation,stations)){
                        //System.out.println("您应付的车费为：");
                        startIndex=countStation(startStation,stations);
                        endIndex=countStation(endStation,stations);
                        //计算经过的中站
                        passStation=startIndex>endIndex?startIndex-endIndex:endIndex-startIndex;
                        int money=countMoney(passStation);
                        System.out.println("中途经过"+passStation+"站");
                        System.out.println("您应付的车费为："+money);
                        return;
                    }else {
                        System.out.println("站名不存在请重新输入！");
                    }
                }

            }else {
                System.out.println("站名不存在请重新输入！");
                continue;
            }
        }



    }

    //判断是否存在
    public static boolean isExist(String addr,TreeMap<Integer,String> stations){
        if (stations.containsValue(addr)){
            return true;
        }
        return false;
    }

    //计算车费
    public static int countStation(String addr,TreeMap<Integer,String> station){
        int goal=0;
        if (station.containsValue(addr)){
            Set<Map.Entry<Integer, String>> entrySet = station.entrySet();
            for (Map.Entry<Integer, String> entry : entrySet) {
                int key=entry.getKey();
                String startValue=entry.getValue();
                if (startValue.equals(addr)){
                    goal=key;
                }
            }
        }
        return goal;
    }

    //计算车费
    public static int countMoney(int total){
        int money=0;
        if (total>0&&total<=3){
            money=3;
        }else if(total>3&&total<=5){
            money=4;
        }else if (total>8){
            money=10;
        }else if (total>5&&total<=8){
            money=(total-5)*2+4;
        }
        return money;
    }