JAVASE基础模块二十六（Map集合 HashMap LinkedHashMap Hashtable TreeMap）

最新推荐文章于 2024-04-16 18:09:14 发布
最新推荐文章于 2024-04-16 18:09:14 发布
阅读量148 收藏
点赞数 1
文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cx9977/article/details/107859364
版权

JAVASE基础模块二十六（Map集合 HashMap LinkedHashMap Hashtable TreeMap）

MaP集合

  • 在生活中 有一种数据比较常见 比如一个 学号—学生

    1. “s001”----------“张三”
    2. “s002”----------“张四”
    3. “s003”----------“张五”
    import java.util.ArrayList;
import java.util.Arrays;
public class Test {
    public static void main(String[] args) {
        ArrayList<String> d = new ArrayList<>();
        d.add("s001----------张三");
        d.add("s002----------张四");
        d.add("s003----------张五");
        System.out.println(Arrays.toString(d.get(0).split("-+")));        System.out.println(Arrays.toString(d.get(0).split("-+")));       System.out.println(Arrays.toString(d.get(0).split("-+")));
        }
}
运行结果：
[s001, 张三]
[s001, 张三]
[s001, 张三]

Process finished with exit code 0

  • JAVA对于这种键值映射到值的数据对象 为了方便我们操作 提供了Map集合

  • Map之所以被称为双列集合 是由于它有键 有值

  • Map分类

    1. HashMap
    2. HashTable
    3. LinkedHashMap
    4. TreeMap

  • 特点：所有双列集合的数据结构 只跟键有关 跟值没关系

    1. Map：双列集合 一个键只能映射一个值 键相同 值就会被覆盖
    2. HashMap：键的数据结构是哈希表 键无序且唯一 并且允许使用null值和null键 线程不安全 效率高
    3. Hashtable：不允许null值和null键 线程安全 效率低
    4. LinkedHashMap：键的数据结构是链表和哈希表 键有序且唯一 链表保证有序 哈希表保证唯一
    5. TreeMap

    HashMap

    1. 添加元素 d.put(“莱茵科技”, “uu”);
    2. 当键相同 值覆盖 返回的是上一次这个键所映射的旧值
    3. 当键名为英文时键值顺序为有序
    4. 当键名为中文时键值顺序为无序
    import java.util.HashMap;

public class HashM {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        String f=d.put("莱茵科技", "uu");//添加元素
        //当键相同 值覆盖 返回的是上一次这个键所映射的旧值
        String f1=d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        System.out.println(d);//顺序为无序
        System.out.println(f);
        System.out.println(f1);
    }
}
运行结果：
{阿米娅=ee, 银灰=ww, 莱茵科技=22, 博士=tt}
null
uu

Process finished with exit code 0

    1. 方法

      • 清空
      import java.util.HashMap;

public class ShanChu {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        //清空集合
        d.clear();
        //集合长度
        System.out.println(d.size());
    }
}
运行结果：
0
Process finished with exit code 0
      • 其他方法
      import java.util.HashMap;

public class Sc {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        //集合长度
        System.out.println(d.size());
        //返回的是键对应的值
        String dd = d.remove("博士");
        System.out.println(dd);
        System.out.println(d);
        //键是否存在
        System.out.println(d.containsKey("博士"));
        System.out.println(d.containsKey("银灰"));
        //通过键来获取值
        System.out.println(d.get("阿米娅"));
        System.out.println(d.get("崖心"));
        //通过键来获取值 找不到返回备用
         System.out.println(d.getOrDefault("崖心心", "发发"));
        //判断集合是否为空
        System.out.println(d.isEmpty());
    }
}
运行结果：
4
tt
{阿米娅=ee, 银灰=ww, 莱茵科技=22}
false
true
ee
null
发发
false

Process finished with exit code 0

  • 双列集合的遍历

    1. 键找值 遍历HashMap
    import java.util.HashMap;
import java.util.Set;

public class Bl1 {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        Set<String> dd = d.keySet();
        for (String s : dd) {
            System.out.println(s+"\t"+d.get(s));
        }
    }
}
运行结果：
阿米娅	ee
银灰	ww
莱茵科技	22
博士	tt

Process finished with exit code 0
    1. entrySet() 遍历HashMap
    package com.westos.X2;

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

public class Bl2 {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        Set<Map.Entry<String, String>> ff = d.entrySet();
        for (Map.Entry<String, String> ee : ff) {
        System.out.println(ee);
          
        }
    }
}
运行结果：
阿米娅=ee
银灰=ww
莱茵科技=22
博士=tt

Process finished with exit code 0
    1. values() 值得获取
    import java.util.Collection;
import java.util.HashMap;

public class Zhi {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        Collection<String> dd = d.values();
        for (String s : dd) {
            System.out.println(s);
        }

    }
}
运行结果：
ee
ww
22
tt

Process finished with exit code 0

  • 键名相同与不同问题

    1. 键名为string 值为student
    import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Stu {
    public static void main(String[] args) {
        HashMap<String, Student> d = new HashMap<>();
        d.put("莱茵科技", new Student("22"));
        d.put("博士", new Student("33"));
        d.put("阿米娅", new Student("44"));
        d.put("阿米娅", new Student("49"));
        d.put("银灰", new Student("55"));
        d.put("银灰", new Student("66"));
        Set<Map.Entry<String, Student>> ff = d.entrySet();
        for (Map.Entry<String, Student> ee : ff) {
            System.out.println(ee);
        }

    }
}

class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
运行结果：
阿米娅=Student{name='49'}
银灰=Student{name='66'}
莱茵科技=Student{name='22'}
博士=Student{name='33'}

Process finished with exit code 0

    1. 键名为stud 值为string

      • 比较地址值而不是名字
      import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
public class Mxt {
    public static void main(String[] args) {
        HashMap<Stud,String> d = new HashMap<>();
        d.put(new Stud("弎屲"),"莱茵科技" );
        d.put( new Stud("弎屲"),"博士");
        d.put( new Stud("弎屲"),"阿米娅");
        d.put(new Stud("信息"),"阿米娅");
        d.put( new Stud("大大"),"银灰");
        d.put(new Stud("方方"),"银灰");
        Set<Map.Entry<Stud,String>> ff = d.entrySet();
        for (Map.Entry<Stud,String> ee : ff) {
            System.out.println(ee);
        }

    }
}
class Stud{
    private String name;

    public Stud(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
运行结果：
Student{name='弎屲'}=莱茵科技
Student{name='大大'}=银灰
Student{name='弎屲'}=阿米娅
Student{name='弎屲'}=博士
Student{name='信息'}=阿米娅
Student{name='方方'}=银灰

Process finished with exit code 0
      • 原因 HashMap重写了hashCode()与equals()方法
      import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
public class Mxt {
    public static void main(String[] args) {
        HashMap<Stud,String> d = new HashMap<>();
        d.put(new Stud("弎屲"),"莱茵科技" );
        d.put( new Stud("弎屲"),"博士");
        d.put( new Stud("弎屲"),"阿米娅");
        d.put(new Stud("信息"),"阿米娅");
        d.put( new Stud("大大"),"银灰");
        d.put(new Stud("方方"),"银灰");
        Set<Map.Entry<Stud,String>> ff = d.entrySet();
        for (Map.Entry<Stud,String> ee : ff) {
            System.out.println(ee);
        }

    }
}
class Stud{
    private String name;

    public Stud(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Stud stud = (Stud) o;
        return Objects.equals(name, stud.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}
运行结果：
Student{name='方方'}=银灰
Student{name='大大'}=银灰
Student{name='信息'}=阿米娅
Student{name='弎屲'}=阿米娅

Process finished with exit code 0

Hashtable

  • 区别

    1. HashMap键的数据结构是哈希表 键无序且唯一 并且允许使用null值和null键 线程不安全 效率高
    2. Hashtable不允许null值和null键 线程安全 效率低
    import java.util.HashMap;
import java.util.Hashtable;

public class HashT {
    public static void main(String[] args) {
        HashMap<String, String> d = new HashMap<>();
        d.put(null,null);
        Hashtable<String, String> dd = new Hashtable<>();
        dd.put(null,"hh");
        dd.put("nu",null);
        dd.put(null,null);

    }
}
运行结果：报错
Exception in thread "main" java.lang.NullPointerException

LinkedHashMap

  • 特点：键的数据结构是链表和哈希表 键有序且唯一 链表保证有序 哈希表保证唯一

    import java.util.LinkedHashMap;

public class LinkedH {
    public static void main(String[] args) {
        LinkedHashMap<String, String> d = new LinkedHashMap<>();
        d.put("莱茵科技", "22");
        d.put("博士", "tt");
        d.put("阿米娅", "ee");
        d.put("银灰", "ww");
        d.put("莱茵", "22");
        d.put("博", "tt");
        d.put("米娅", "ee");
        d.put("灰", "ww");
        System.out.println(d);
    }
}
运行结果：
{莱茵科技=22, 博士=tt, 阿米娅=ee, 银灰=ww, 莱茵=22, 博=tt, 米娅=ee, 灰=ww}

Process finished with exit code 0

TreeMap

  • 当键名为数值时会进行大小排序
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class TreeM {
    public static void main(String[] args) {
        TreeMap<Integer, String> d = new TreeMap<>();
        d.put(10,"莱茵科技");
        d.put(55,"博士");
        d.put(99,"阿米娅");
        d.put(46,"银灰");
        d.put(13,"莱茵");
        d.put(2,"博");
        d.put(66,"米娅");
        d.put(77,"灰");
        Set<Map.Entry<Integer,String>> ff = d.entrySet();
        for (Map.Entry<Integer,String> ee : ff) {
            System.out.println(ee);
        }
    }
}
运行结果：
2=博
10=莱茵科技
13=莱茵
46=银灰
55=博士
66=米娅
77=灰
99=阿米娅

Process finished with exit code 0
  • 当键名为字符串时会按照字典索引排序
import java.util.LinkedHashMap;
import java.util.TreeMap;

public class Jian {
    public static void main(String[] args) {
        TreeMap<String, String> d = new TreeMap<>();
        d.put("dft","莱茵科技");
        d.put("ert","博士" );
        d.put("asd","阿米娅 ");
        d.put("hui","银灰");
        d.put("iuy","莱茵" );
        d.put("bgt","博");
        d.put("gry","米娅" );
        d.put("fer","灰");
        System.out.println(d);
    }
}

运行结果：
{asd=阿米娅 , bgt=博, dft=莱茵科技, ert=博士, fer=灰, gry=米娅, hui=银灰, iuy=莱茵}

Process finished with exit code 0
  • 当键名为自定义类型时 要传入比较器进行比较
package com.westos.X2;

import java.util.*;

public class ZiDingYi {
    public static void main(String[] args) {
        TreeMap<Stude, String> d = new TreeMap<>(new Comparator<Stude>() {
            @Override
            public int compare(Stude o1, Stude o2) {
                int num = o1.getAge() - o2.getAge();
                int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num2;
            }
        });
        d.put(new Stude("弎屲", 98), "莱茵科技");
        d.put(new Stude("弎屲", 56), "博士");
        d.put(new Stude("弎屲", 23), "阿米娅");
        d.put(new Stude("信息", 111), "阿米娅");
        d.put(new Stude("大大", 85), "银灰");
        d.put(new Stude("方方", 22), "银灰");
        Set<Map.Entry<Stude, String>> ff = d.entrySet();
        for (Map.Entry<Stude, String> ee : ff) {
            System.out.println(ee);
        }
    }
}

class Stude {
    private String name;
    private int age;

    public Stude(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Stude{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：
Stude{name='方方', age=22}=银灰
Stude{name='弎屲', age=23}=阿米娅
Stude{name='弎屲', age=56}=博士
Stude{name='大大', age=85}=银灰
Stude{name='弎屲', age=98}=莱茵科技
Stude{name='信息', age=111}=阿米娅

Process finished with exit code 0
  • 利用Map统计字符个数
import java.util.Scanner;
import java.util.TreeMap;
public class LianXi {
    public static void main(String[] args) {
        TreeMap< Character,Integer> dd = new TreeMap<>();
        Scanner d = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s=d.nextLine();
        for (int i = 0; i < s.length(); i++) {
            if(!dd.containsKey(s.charAt(i))){
                dd.put(s.charAt(i),1);
            }else{
                int m=dd.get(s.charAt(i));
                m++;
                dd.put(s.charAt(i),m);
            }
        }
    }
}
运行结果：
请输入字符串
hfuseirallgarurahaflhaeuaefhlvjkdslv
{a=6, d=1, e=3, f=3, g=1, h=4, i=1, j=1, k=1, l=5, r=3, s=2, u=3, v=2}

Process finished with exit code 0

待续…

弎屲
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaSE_集合.zip
07-21
JavaSE集合的全部内容，大大小小重点，全部包含，内容之多之全，首先声明，这是一个完全完整的集合全部重点内容，如果您难呢过坚持下来一个一个知识点去攻破，那恭喜你，集合的知识你差不多已经足够掌握了，妈妈再也...
JavaSE进阶 | Map集合、HashMap集合、TreeMap集合
m0_61933976的博客
07-24 1573
JavaSE进阶 | Map集合、HashMap集合、TreeMap集合
Java中HashMap、Hashtable、LinkedHashMap、TreeMap特点和区别
weixin_42263032的博客
07-17 509
Java中HashMap、Hashtable、LinkedHashMap、TreeMap特点和区别
11.Map集合之实现类HashMap&Hashtable&TreeMap&LinkedHashMap&Properties浅析
zhaozhiwei314的博客
07-09 163
在我们生活中，集合的概念就已经不陌生，比如身份证号对应的就一个人、电脑IP地址对应的就是主机名、学号对应就是一个学生等，其实就是一种一一对应的关系，我们可以认为这就是映射.在Java中就提供了专门的集合类用来存放这种对象(映射)关系的对象，即java.util...
JAVASE-21：Map集合及其子类HashMap 、Hashtable、LinkedHashMap 、TreeMap
Hannen的博客
08-08 255
集合Map 有一种数据比较常见，比如一个学号对应一个学生，这种键值映射关系的数据，为了方便操作，给我们提供了另一种容器，叫做Map：称之为双列集合，有键 有映射值，一个键只能映射一个值，键是唯一的，如果键相同，那么值会覆盖。 所有的双列集合的数据结构，只跟键有关，跟值没有关系。 Map接口和Collection接口的不同： Map是双列的,Collection是单列的； Map的键唯一,Collection的子体系Set是唯一的； Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构
JavaSE基础面试题.docx
06-11
17.HashMap、Hashtable、ConcurrentHashMap底层实现原理及区别 18.HashMap底层数据结构 19.说说HashMap如何处理碰撞的，或者说说它的扩容？ 20.jdk7/8中对HashMap做了哪些改变？ 21.负载因子为什么会影响HashMap性能...
JavaSE基础（一）
07-19
变量名、方法名：多单词组成时，第一个首字母小写，第二个首字母后大写：xxxYyyZzz 4、Java注释 单行注释：“//”只能注释一行内容，用在注释信息内容少的地方。 多行注释：“/*”和“*/”之间，注释多行内容。 文档...
JavaSE基础.md
06-29
javaSE基础，查漏补缺必备
Studentmanger.zip_javase基础
09-23
javase基础，简单学生管理系统，初级练手用
实现队列的各种基本运算的算法（数据结构）
2301_79819250的博客
04-14 267
队列的特点就是先进先出，后进后出。
数据结构—单链表
2301_80418043的博客
04-16 931
介绍一下单链表的英文名——single linked list，我们简写成SL（区别于顺序表的SeqList或者SQL）。注意：next指针的类型是SListNode*，千万不要写成SLTDataType*，因为next指针是结构体指针，是用来指向下一个结点的}SLTNode;
C语言中的数据结构--双向链表
2301_78694309的博客
04-12 1394
C语言实现双向链表
数据结构之单链表的相关知识点及应用
我要学编程的博客
04-13 1112
数据结构之单链表的相关知识点及应用
二叉树-数据结构
lq
04-12 262
*树的层次：**从根节点开始，假设根节点是第一层，根节点的子节点为第二层，一次类推，如果某一个节点位于第L层，则其子节点位于第 L+1层。**树的深度：**也成树的高度，树中所有节点的层次最大值称为树的深度。**叶子节点：**也称为终端节点，没有子树的节点或者 度为零的节点。**分支节点：**也成非终端节点，有子树的节点或者 度不为零的节点。**节点的度：**一个节点拥有子树的数量称为节点的度。**节点的高度：**从节点到其子树叶子节点最长的路径。**节点的深度：**从根节点到节点的路径长度。
[数据结构]——二叉树——堆排序
最新发布
2303_77720864的博客
04-16 535
后续代码以此为基础。
数据结构6.3:二叉树的查找和删除
qq_55630615的博客
04-13 272
因为二叉树的单向特性,所以应该对父节点判断其子节点是否需要删除,而非判断本身是否需要被删除.如果传入的是一个空树,可以在树中对root节点进行判断,如果为空直接返回即可。如果不等,先判断左子节点是否为空,不为空就对左子节点递归前序查找。判断当前节点的左子节点是否为空,不为空就对左子节点递归后序查找。先判断左子节点是否为空,不为空就对左子节点递归中序查找。再判断右子节点是否为空,对右子节点递归前序查找。再判断右子节点是否为空,对右子节点递归中序查找。再判断右子节点是否为空,对右子节点递归后序查找。
【数据结构】AVL树
2301_76762420的博客
04-13 805
首先，我们定义AVL树的节点结构。节点包含一个整数值value，指向左子树和右子树的指针left和right，以及一个表示子树高度的字段height。int value;int height;} AVLNode;AVL树是一种自平衡二叉搜索树，通过维护树的高度平衡来确保树的操作复杂度为O(log n)。它提供了查找、插入和删除操作的对数时间复杂度，非常适合需要快速操作和高性能的数据结构。
算法与数据结构 栈队列 （C++）
2301_80790320的博客
04-13 210
5．随机产生10个100以内的整数建立链队列，显示链队列中所有数据元素；从键盘输入出队元素个数 n (1<= n <=10)，将 n 个元素出队后显示此时的队头元素。
javase用map集合对图书进行增删改查
01-11
使用JavaSE中的Map集合可以很方便地对图书进行增删改查操作。Map集合是一种键值对的集合，通过键来快速查找对应的值。 首先，我们可以创建一个Map集合来保存图书信息，其中键可以是图书的名称、编号等唯一标识，值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值