Java笔记_13(集合进阶2)

news2025/1/23 2:22:42

Java笔记_13

  • 一、双列集合
    • 1.1、Map的常见API
    • 1.2、Map遍历方式一（键找值）
    • 1.3、Map集合遍历方法二（键值对）
    • 1.4、Map集合遍历方法三（lambda表达式）
    • 1.5、HashMap
    • 1.6、HashMap练习
    • 1.7、HashMap底层源码解析
    • 1.7、LinkedHashMap
    • 1.8、TreeMap

一、双列集合

双列集合体系结构：
在这里插入图片描述

双列集合的特点：

  1. 双列集合一次需要存一对数据，分别为键和值
  2. 键不能重复，值可以重复
  3. 键和值是一一对应的，每一个键只能找到自己对应的值
  4. 键＋值这个整体我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象”

1.1、Map的常见API

Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的

方法名称说明
v put(K key,v value)添加元素
v remove(object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(object key)判断集合是否包含指定的键
boolean containsValue(object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数
  • put方法细节
    • 在添加数据的时候，如果键不存在，那么直接把键值对对象添加到Map集合中，方法返回null
    • 在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把被覆盖的值进行返回。
package Collection_two_Dome.MapDome;

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

public class Dome1 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        map.put("康师傅","kangshufu");
        map.put("可口","百事");
        map.put("段子","皮皮");
        map.put("可口","美年达");//会覆盖上面的可口

        map.put("段子","123");
        System.out.println(map);

        map.remove("康师傅");
        System.out.println(map);
        System.out.println(map.size());//集合长度
        //判断是否存在键
        boolean keyResult = map.containsKey("康师傅");
        System.out.println(keyResult);
        //判断是否存在值
        boolean ValueResult = map.containsValue("美年达");
        System.out.println(ValueResult);

        //清空
        map.clear();
        System.out.println(map.isEmpty());
        System.out.println(map);
    }
}

1.2、Map遍历方式一（键找值）

三种遍历方式

  • 迭代器遍历
  • 增强for遍历
  • forEach遍历
package Collection_two_Dome.MapDome;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;

public class Dome2 {
    public static void main(String[] args) {

        Map<String,Integer> map = new HashMap<>();

        map.put("可乐",3);
        map.put("康师傅",1);
        map.put("汇源",5);
        map.put("沙市",4);

        Iterator it = map.keySet().iterator();
        while (it.hasNext()){
            Object next = it.next();
            int money = map.get(next);
            System.out.println(next +"="+money);
        }
        System.out.println("--------- ------------------------------");
        Set<String> strings = map.keySet();

        for (String string : strings) {
            int money = map.get(string);
            System.out.println(string+"="+money);
        }

        strings.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                Integer money = map.get(s);
                System.out.println(s+"="+money);
            }
        });
    }
}

1.3、Map集合遍历方法二（键值对）

  1. 利用entrySet方法返回一个Set集合
  2. 这个集合里面装的是键值对对象
  3. 在通过get方法分别得到key和value
package Collection_two_Dome.MapDome;

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

public class Dome3 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();

        map.put("可乐",3);
        map.put("康师傅",1);
        map.put("汇源",5);
        map.put("沙市",4);
        //通过entrySet()方法获得装键值对的set集合
        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        for (Map.Entry<String, Integer> entry : entries) {
            //通过get方法依次得到键和值
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

1.4、Map集合遍历方法三（lambda表达式）

方法名称说明
default void forEach(Biconsumer<? super K,? super V> action)结合lambda遍历Map集合
package Collection_two_Dome.MapDome;

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class Dome4 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();

        map.put("可乐",3);
        map.put("康师傅",1);
        map.put("汇源",5);
        map.put("沙市",4);

        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s+"="+ integer);
            }
        });
        System.out.println("-----------------------------------");

        map.forEach((String s, Integer integer)->{
                System.out.println(s+"="+ integer);
            }
        );
        System.out.println("-----------------------------------");
    }
}

1.5、HashMap

HashMap的特点

  1. HashMap是Map里面的一个实现类。
  2. 没有额外需要学习的特有方法，直接使用Map里面的方法就可以了。
  3. 特点都是由键决定的:无序、不重复、无索引
  4. HashMap跟HashSet底层原理是一模一样的，都是哈希表结构
  5. 依赖hashcode方法和equals方法保证键的唯一
  • 如果键存储的是自定义对象，需要重写hashCode和equals方法
  • 如果值存储的是自定义对象，不需要重写hashCode和equals方法

1.6、HashMap练习

在这里插入图片描述

package Collection_two_Dome.HashMapDome;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

public class Dome1 {
    public static void main(String[] args) {
        HashMap<student,String> hm = new HashMap<>();

        student s1 = new student("xiaoming",18);
        student s2 = new student("xiaowang",19);
        student s3 = new student("xiaoli",18);
        student s4 = new student("xiaoming",18);

        hm.put(s1,"henan");
        hm.put(s2,"guangdong");
        hm.put(s3,"jiangsu");
        hm.put(s4,"shandong");

       hm.forEach((student student, String s)->{
                System.out.println(student+" "+s);
            }
        );

        System.out.println("-------------------------------------");

        Set<Map.Entry<student, String>> hms = hm.entrySet();
        for (Map.Entry<student, String> studentStringEntry : hms) {
            System.out.println(studentStringEntry);
        }

        System.out.println("-------------------------------------");

        Iterator it = hm.entrySet().iterator();
        while (it.hasNext()){
            Object next = it.next();
            System.out.println(next);
        }

    }
}

在这里插入图片描述

package Collection_two_Dome.HashMapDome;

import java.util.*;

public class Dome2 {
    public static void main(String[] args) {
        //创建数组，记录四个景点
        String[] arr = {"黄山","泰山","华山","佘山"};
        //利用随机数模拟80个同学的投票票
        //通过集合的形式记录每个景点的票数
        Random r =new Random();
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < 80; i++) {
            int index = r.nextInt(arr.length);
            list.add(arr[index]);
        }
        //定义Map集合，利用集合进行统计
        HashMap<String,Integer> hm = new HashMap<>();
        for (String name : list) {
            //判断当前景点在map集合中是否存在
            if(hm.containsKey(name)){
                //先得到这个景点的次数
                int count = hm.get(name);
                //在进行++
                count++;
                //重新存入
                hm.put(name,count);
            }else {
                hm.put(name,1);
            }
        }

        System.out.println(hm);

        //求最大值
        int max = 0;
        //比较得出最大值
        Set<Map.Entry<String, Integer>> entries = hm.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            if(entry.getValue()>max){
                max= entry.getValue();
            }
        }
        System.out.println(max);
        //再次通过遍历的到最大票数的景点

        for (Map.Entry<String, Integer> entry : entries) {
            if (max== entry.getValue()){
                System.out.println(entry.getKey());
            }
        }

    }
}

1.7、HashMap底层源码解析

添加第一个元素的底层原理
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
数组位置不为null，键不重复，挂在下面形成链表或者红黑树

1.7、LinkedHashMap

  • 由键决定:有序、不重复、无索引。
  • 这里的有序指的是保证存储和取出的元素顺序一致
  • 原理∶底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序。

在这里插入图片描述

package Collection_two_Dome.LinkedHashMapDome;

import java.util.LinkedHashMap;

public class Dome1 {
    public static void main(String[] args) {
        LinkedHashMap<String,Integer> linkedHashMap = new LinkedHashMap<>();

        linkedHashMap.put("可乐",3);
        linkedHashMap.put("百事",3);
        linkedHashMap.put("沙市",4);
        linkedHashMap.put("北冰洋",5);
        linkedHashMap.put("可口",3);
        linkedHashMap.put("芬达",3);
        linkedHashMap.put("雪碧",3);
        linkedHashMap.put("可乐",4);//键相同时，回覆盖掉原来的值

        System.out.println(linkedHashMap);
    }
}

1.8、TreeMap

  • TreeMap跟TreeSet底层原理一样，都是红黑树结构的。
  • 由键决定特性:不重复、无索引、可排序
  • 可排序：对键进行排序。
  • 注意：默认按照键的从小到大进行排序，也可以自己规定键的排序规则

代码书写两种排序规则

  • 实现Comparable接口，指定比较规则。
  • 创建集合时传递Comparator比较器对象，指定比较规则。
    在这里插入图片描述
package Collection_two_Dome.TreeMapDome;

import java.util.Comparator;
import java.util.TreeMap;

public class Dome1 {
    public static void main(String[] args) {

        TreeMap<Integer,String> tm = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;//此时Integer按照降序排列
            }
        });
        //默认情况下Integer 和Double类型是按照升序的方法进行排列
        tm.put(1,"火车");
        tm.put(4,"游艇");
        tm.put(5,"出租");
        tm.put(2,"公交");
        tm.put(7,"大巴");
        tm.put(6,"汽车");
        tm.put(8,"飞机");

        System.out.println(tm);
    }
}

在这里插入图片描述

package Collection_two_Dome.TreeMapDome;

import java.util.Comparator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Dome2 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int i = o1.getAge()- o2.getAge();
                i = i==0?o1.getName().compareTo(o2.getName()):i;

                return i;
            }
        });

        Student s1 = new Student("chen",18);
        Student s2 = new Student("lu",19);
        Student s3 = new Student("huang",17);
        Student s4 = new Student("jia",19);
        Student s5 = new Student("qian",18);
        Student s6 = new Student("gao",20);


        tm.put(s1,"广东");
        tm.put(s2,"河南");
        tm.put(s3,"四川");
        tm.put(s4,"山西");
        tm.put(s5,"江苏");
        tm.put(s6,"云南");

        Set<Map.Entry<Student, String>> entries = tm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            System.out.println(entry);
        }
    }
}
package Collection_two_Dome.TreeMapDome;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

在这里插入图片描述

package Collection_two_Dome.TreeMapDome;

import java.util.Map;
import java.util.Set;
import java.util.StringJoiner;
import java.util.TreeMap;
import java.util.function.BiConsumer;

public class Dome3 {
    public static void main(String[] args) {

        String s = "asdasdasdasdasdddasdasdaddadfffaasffafasffff";

        TreeMap<Character,Integer> tm = new TreeMap<>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(tm.containsKey(c)){
                Integer count = tm.get(c);
                count++;
                tm.put(c,count);
            }else {
                tm.put(c,1);
            }
        }

        StringBuilder sb = new StringBuilder();

        tm.forEach((character,integer)->sb.append(character).append("(").append(integer).append(")"));
        System.out.println(sb);
        //使用StringJoiner方法时需要定义开头末尾以及中间每个元素之间的间隔字符
        StringJoiner sj  =new StringJoiner("","","");/*使用StringJoiner的add方法时一定要添加字符串&*/
        tm.forEach(( character,  integer)->sj.add(character+"").add("(").add(integer+"").add(")"));
        System.out.println(sj);



    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/468628.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

12秒内AI在手机上完成作画！谷歌提出扩散模型推理加速新方法

12秒内AI在手机上完成作画！谷歌提出扩散模型推理加速新方法

本文源自&#xff1a;量子位 只需12秒&#xff0c;只凭手机自己的算力&#xff0c;就能拿Stable Diffusion生成一张图像。 而且是完成了20次迭代的那种。 要知道&#xff0c;现在的扩散模型基本都超过了10亿参数&#xff0c;想要快速生成一张图片&#xff0c;要么基于云计算&…
阅读更多...
Python 实现txt、excel、csv文件读写【附源码】

Python 实现txt、excel、csv文件读写【附源码】

目录 前言 一、txt文件读写 二、excel文件读写 总结 前言 本文介绍使用Python进行文件读写操作&#xff0c;包括txt文件、excel文件(xlsx、xls、csv) 编译器使用的是PyCharm 一、txt文件读写 read() # 一次性读取全部内容readline() # 读取第一…
阅读更多...
K8s入门教程：10分钟带你速览全程

K8s入门教程：10分钟带你速览全程

K8s&#xff0c;英文全称为Kubernetes&#xff0c;就是基于容器的集群管理平台&#xff0c;是用于自动部署、扩缩和管理容器化应用程序的开源系统。 K8s是用来干啥的&#xff1f; 简单来说&#xff0c;可以用一句话来解释&#xff1a;K8s的特点就是所有主机上都装上docker&…
阅读更多...
Win10老是蓝屏收集错误信息重启无效怎么办？

Win10老是蓝屏收集错误信息重启无效怎么办？

Win10老是蓝屏收集错误信息重启无效怎么办&#xff1f;有用户遇到了电脑开机蓝屏的情况&#xff0c;收集错误信息重启电脑之后&#xff0c;依然无法解决问题。那么这个问题要怎么去进行解决呢&#xff1f;接下来我们来看看以下具体的处理方法教学吧。 准备工作&#xff1a; 1、…
阅读更多...
JAVA：基于Redis 实现计数器限流

JAVA：基于Redis 实现计数器限流

1、简述 在现实世界中可能会出现服务器被虚假请求轰炸的情况&#xff0c;因此您可能希望控制这种虚假的请求。 一些实际使用情形可能如下所示&#xff1a; API配额管理-作为提供者&#xff0c;您可能希望根据用户的付款情况限制向服务器发出API请求的速率。这可以在客户端或服…
阅读更多...
Bing 性能是如何跟随 .NET 一起迭代的？

Bing 性能是如何跟随 .NET 一起迭代的？

大约两年前&#xff0c;我发表了一篇文章&#xff0c;详细的介绍了 Bing 的中央工作流引擎(XAP)从 .NET Framework 升级到 .NET 5 的过程。你可以通过这篇文章来了解 XAP 的工作原理&#xff0c;以及它在 Bing 全局中的位置。从那时起&#xff0c;XAP 一直是微软许多搜索和工作…
阅读更多...
mysql语句高级用法使用记录和sql_mode=only_full_group_by错误解决

mysql语句高级用法使用记录和sql_mode=only_full_group_by错误解决

最近工作时用到的几种用法记录一下 sql_modeonly_full_group_by 报错 sql出错示例如下 column ‘qnaq.ta.issue_org_code’ which is not functionally dependent on columns in GROUP BY clause; this is incompatible with sql_modeonly_full_group_by 原因分析&#xff1a;…
阅读更多...
云服务器使用jenkins+docker自动化部署SpringBoot项目

云服务器使用jenkins+docker自动化部署SpringBoot项目

docker 安装jenkins&#xff0c;就这一步都恶心死了 //拉取镜像&#xff0c;踩了很多坑&#xff0c;用其它版本的镜像插件一直安装失败&#xff0c;最后用的是lts版本&#xff08;基础版&#xff09; 用其它版本要么是连不上插件的下载地址&#xff0c;要么是插件下载不成功 d…
阅读更多...
Window10搭建GPU环境（CUDA、cuDNN）

Window10搭建GPU环境（CUDA、cuDNN）

一、查看CUDA版本 方法一&#xff0c;cmd命令 nvidia-smi下图的 CUDA 版本是11.7 方法二&#xff0c;点击 NVIDIA的图标 1.右键点击会出现nvidia 控制面板 或者 2.点击系统信息 3.点击组件 二.下载CUDA 到官网下载根据不同的版本 https://developer.nvidia.com/cud…
阅读更多...
IU5180C升降压充电芯片特点及应用

IU5180C升降压充电芯片特点及应用

IU5180C是一款完全集成的开关模式升降压充电管理IC&#xff0c;用于1~4节鲤离子电池和锂聚合物电池&#xff0c;以及1~5节磷酸铁锂电池。芯片集成包括4开关MOSFET、输入和充电电流感应电路、电池以及升降压转换器的环路补偿。芯片具有3A的充电电流能力&#xff0c;充电电流可以…
阅读更多...
算法套路十三——动态规划DP

算法套路十三——动态规划DP

算法套路十三——动态规划DP 动态规划和递归都是通过将大问题分解为较小的子问题来解决问题。它们都可以用来解决具有重叠子问题和最优子结构特性的问题。在很多情况下&#xff0c;动态规划算法的设计可以从递归算法开始&#xff0c;然后通过添加记忆化&#xff08;Memoizatio…
阅读更多...
Java on Azure Tooling 3月更新｜Azure Event Hubs 支持、Azure Functions 模板增强及日志流改进

Java on Azure Tooling 3月更新｜Azure Event Hubs 支持、Azure Functions 模板增强及日志流改进

作者&#xff1a;Jialuo Gan - Program Manager, Developer Division at Microsoft 排版&#xff1a;Alan Wang 大家好&#xff0c;欢迎来到 Java on Azure Tooling 的3月更新。在这次更新中&#xff0c;我们将介绍 Azure Event Hubs 支持、Azure Functions 的模板增强&#xf…
阅读更多...
力扣sql中等篇练习(十四)

力扣sql中等篇练习(十四)

力扣sql中等篇练习(十四) 1 最后一个能进入电梯的人 1.1 题目内容 1.1.1 基本题目信息 1.1.2 示例输入输出 1.2 示例sql语句 # 在表某一个范围内的可以考虑自连接的方式,注意连接的表只需要精准的字段 # 需要排序是因为它需要找到最后一个上车的用户 SELECT q1.person_name…
阅读更多...
SCA有什么作用？软件成分分析（SCA）技术详解

SCA有什么作用？软件成分分析（SCA）技术详解

软件成分分析&#xff08;SCA&#xff09;是一种用来识别分析某一个软件中所使用的组件与第三方库的来源、版本、许可证信息的技术。这些组件和库可能来源于开源社区、商业供应商或是企业自行开发&#xff0c;其存在很多潜在的安全合规问题。 软件成分分析工具&#xff08;SCA工…
阅读更多...
都23年了你还记得渐进式框架是什么意思吗

都23年了你还记得渐进式框架是什么意思吗

vue 文章目录 vue前言一、眼见为实举个栗子二、渐进式的优势 前言 渐进式框架是一种能够逐步增强应用功能的框架&#xff0c;它允许开发者在不影响应用性能的情况下&#xff0c;逐步添加新的功能和特性。Vue.js提供了一些基础功能&#xff0c;如数据绑定和组件化&#xff0c;然…
阅读更多...
软件测试---BUG的生命周期

软件测试---BUG的生命周期

测试人员最本质的工作就是寻找bug&#xff0c;提交bug、验证bug、推进bug的解决&#xff0c;直至软件达到发布的标准&#xff0c;提高软件的质量&#xff0c;及研发的工作效率和质量。 一、什么是bug 软件的BUG,狭义概念是指软件程序的漏洞或缺陷&#xff0c;广义概念除此之外…
阅读更多...
WuxioLin 反锯齿算法（反走样算法，Xiaolin Wu Anti-aliasing algorithm） C# 代码实现

WuxioLin 反锯齿算法（反走样算法，Xiaolin Wu Anti-aliasing algorithm） C# 代码实现

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、锯齿和反锯齿二、Xiaolin Wu 算法代码1.C#完整代码如下2.举例和测试 总结 前言 笔者前几日自己写了个佳明手表表盘的的一个入门级App&#xff0c;模拟指针…
阅读更多...
LeetCode 598. 范围求和 II

LeetCode 598. 范围求和 II

文章目录 题目要求代码&#xff08;包含解题思路&#xff09; 题目要求 给你一个 m x n 的矩阵 M &#xff0c;初始化时所有的 0 和一个操作数组 op &#xff0c;其中 ops[i] [ai, bi] 意味着当所有的 0 < x < ai 和 0 < y < bi 时&#xff0c; M[x][y] 应该加 1…
阅读更多...
卡尔曼滤波器简介——α−β−γ滤波器

卡尔曼滤波器简介——α−β−γ滤波器

原文&#xff1a;The alpha - beta - gamma filter (kalmanfilter.net) 本章是介绍性的&#xff0c;它描述了α−β和α−β−γ滤波器。这些滤波器经常用于时间序列数据平滑。α−β-(γ)滤波的原则与卡尔曼滤波原理密切相关。 示例 1 – 加权黄金 现在我们已经准备好了第一个…
阅读更多...
OJ刷题 第十三篇

OJ刷题 第十三篇

22102 - 将字符串反序 时间限制 : 1 秒 内存限制 : 128 MB 请将一个给定的字符串反序(字符长度为1到10000&#xff0c;且有可能包含空格)。 输入 反序前的字符串 输出 反序后的字符串 样例 输入 abcd 输出 dcba 答案&#xff1a; C版本1&#xff1a;&#xff08;掌握&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023