JAVA基础学习-集合三-MapHashMap,TreeMap与常用API

Posted 2020-10-22 浪子回头jin不换

森林森

一份耕耘，一份收获

• 博客园
• 首页
• 新随笔
• 联系
• 管理
• 订阅

随笔- 397  文章- 0  评论- 78 

JAVA基础学习day16--集合三-Map、HashMap,TreeMap与常用API

 

一、Map简述

1.1、简述

public interface Map<K,V>

类型参数：

K - 此映射所维护的键的类型 key

V - 映射值的类型 value

该集合提供键--值的映射。key不能重复，一对对的存储方式

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

1.2、方法

嵌套类摘要
static interface	Map.Entry<K,V>  映射项（键-值对）。

 

方法摘要
void	clear()  从此映射中移除所有映射关系（可选操作）。
boolean	containsKey(Object key)  如果此映射包含指定键的映射关系，则返回 true。
boolean	containsValue(Object value)  如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>>	entrySet()  返回此映射中包含的映射关系的 Set 视图。
boolean	equals(Object o)  比较指定的对象与此映射是否相等。
V	get(Object key)  返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int	hashCode()  返回此映射的哈希码值。
boolean	isEmpty()  如果此映射未包含键-值映射关系，则返回 true。
Set<K>	keySet()  返回此映射中包含的键的 Set 视图。
V	put(K key, V value)  将指定的值与此映射中的指定键关联（可选操作）。
void	putAll(Map<? extends K,? extends V> m)  从指定映射中将所有映射关系复制到此映射中（可选操作）。
V	remove(Object key)  如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
int	size()  返回此映射中的键-值映射关系数。
Collection<V>	values()  返回此映射中包含的值的 Collection 视图。

 1.3、常用子类

HashTable:底层是哈希表，不可以存入Null键Null值，线程是同步的JDK1.0效率低

HashMap：基于哈希表数据结构。允许使用Null键Null值，但只有一个Null键，线程非同步的。JDK1.2效率高

TreeMap：二叉树，线程不同步。可以用于给Map集中的key键进行排序。

和Sety集合很像，Set底层就是Map集合。

1.4、Put

添加元素，添加相同的键，那么后添加的值会覆盖的Vaule，put方法会返回被覆盖的值。

 

 

 

二、HashMap

2.1、常用方法

 

package com.pb.map.demo1;

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

public class MapDemo1 {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        //添加
        map.put("01", "zhangsan");
        System.out.println(map.put("01", "lisi002"));//zhangsan
        map.put("02", "wangwu03");
        map.put("03", "wangwu04");
        map.put(null, "ffff");
        map.put("04", "qqquqq");
        //判断有没有key
        System.out.println(map.containsKey("02"));//true
        //判断 有这有 这个value
        System.out.println(map.containsValue("ffff"));//true
        //获取
        System.out.println(map.get("03"));//wangwu04
        System.out.println(map.get(null));//ffff
        System.out.println(map.get("fdsfdsf"));//null
        System.out.println(map.remove("02"));//返回value的值
        System.out.println(map.remove("0fdsfd"));//没有就返回null
        System.out.println(map);//{null=ffff, 01=lisi002, 03=wangwu04, 04=qqquqq} 是无序的
    }

}

 

 

2.2、key和values

keySet：将map中所有的键 存入到Set集合。因为set具备迭代器。返回为set集合

          可以迭代方式取出所有的键，在根据get方法，获取每一个键对应的值。

 

package com.pb.map.demo1;

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

public class MapDemo2 {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
            //添加
                map.put("09", "zhaoliu");    
                map.put("01", "zhangsan");            
                map.put("02", "wangwu03");
                map.put("03", "wangwu04");
                map.put("04", "qqquqq");
                //获取map集合中的所有键的集合
                Set<String> keySet=map.keySet();
                //迭代所有键来获取值
                Iterator<String> iterator=keySet.iterator();
                while(iterator.hasNext()){
                    String key=iterator.next();
                    //通过map.get(键)的方式来获取值
                    System.out.println(key+".........."+map.get(key));
                }
    }

}

 

 

entrySet:返回为Set<Map.Entry<k,v>> entrySet:将Map集合中的映射关系存入到Set 集合中，而这个关系的数据类型就是Map.Entry

 

Map.entrySet()

 

---

 

 

 

方法摘要
boolean	equals(Object o)  比较指定对象与此项的相等性。
K	getKey()  返回与此项对应的键。
V	getValue()  返回与此项对应的值。
int	hashCode()  返回此映射项的哈希码值。
V	setValue(V value)  用指定的值替换与此项对应的值（可选操作）。

 

package com.pb.map.demo2;

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

/**
 * 学生属性：姓名，年龄
 * 注意姓名和年龄相同的视为同一个学生
 * 1.描述学生
 * 2.定义map容器，将学生做为键，地址作为值、值入
 * 3.获取map集合的元素
 */

//学生类
class Student implements Comparable<Student>{
    private String name;
    private int age;
    
    //让对象本身具备比较性
    @Override
    public int compareTo(Student s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        return num;
    }
    
    /*
     * 重写hash
     */
    @Override
    public int hashCode(){
        return name.hashCode()+age*33;
    }
    /*
     * 重写equals
     */
    @Override
    public boolean equals(Object obj){
        if(!(obj instanceof Student)){
            throw new ClassCastException("类型不匹配");
        }
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.age==stu.age;
        
    }
    
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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 void show(){
        System.out.println(this.name+"...."+this.age);
    }
    
}
public class MapTest {

    public static void main(String[] args) {
        Map<Student,String> map=new HashMap<Student,String>();
        map.put(new Student("lisi01",21), "北京");
        map.put(new Student("lisi01",21), "上海");//覆盖第一个值
        map.put(new Student("lisi02",23), "深圳");
        map.put(new Student("lisi04",22), "武汉");
        map.put(new Student("lisi03",24), "天津");
        System.out.println("======keySet方法======");
        //第一种遍历方式
        Set<Student> keySet=map.keySet();
        Iterator<Student> it=keySet.iterator();
        while(it.hasNext()){
            Student stu=it.next();
            String add=map.get(stu);
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
        System.out.println("======entrySet方法======");
        //第二种遍历方式
        Set<Map.Entry<Student, String>> entrySet=map.entrySet();
        Iterator<Map.Entry<Student, String>> iter=entrySet.iterator();
        while(iter.hasNext()){
            Map.Entry<Student, String> student=iter.next();
            Student stu=student.getKey();
            String add=student.getValue();
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
    }

}

======keySet方法======
lisi01...21....上海
lisi02...23....深圳
lisi04...22....武汉
lisi03...24....天津
======entrySet方法======
lisi01...21....上海
lisi02...23....深圳
lisi04...22....武汉
lisi03...24....天津

 

 

 

 

三、TreeMap

3.1、TreeMap排序

 

package com.pb.map.demo2;

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

/**
 * 学生属性：姓名，年龄
 * 注意姓名和年龄相同的视为同一个学生
 * 1.描述学生
 * 2.定义map容器，将学生做为键，地址作为值、值入，
 * 3.对学生排序按姓名排序
 * 3.获取map集合的元素
 * 
 */

//学生类
class Student implements Comparable<Student>{
    private String name;
    private int age;
    
    //让对象本身具备比较性
    @Override
    public int compareTo(Student s){
        int num=new Integer(this.age).compareTo(new Integer(s.age));
        if(num==0){
            return this.name.compareTo(s.name);
        }
        return num;
    }
    
    /*
     * 重写hash
     */
    @Override
    public int hashCode(){
        return name.hashCode()+age*33;
    }
    /*
     * 重写equals
     */
    @Override
    public boolean equals(Object obj){
        if(!(obj instanceof Student)){
            throw new ClassCastException("类型不匹配");
        }
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.age==stu.age;
        
    }
    
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        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 void show(){
        System.out.println(this.name+"...."+this.age);
    }
    
}
public class MapTest {

    public static void main(String[] args) {
        TreeMap<Student,String> map=new TreeMap<Student,String>(new StudentNameCom());
        
        map.put(new Student("lisi01",21), "上海");//覆盖第一个值
        map.put(new Student("lisi02",23), "深圳");
        map.put(new Student("a",56), "北京");
        map.put(new Student("lisi04",22), "武汉");
        map.put(new Student("lisi03",24), "天津");
        map.put(new Student("a",33), "北京");
        map.put(new Student("lisi01",21), "北京");
        System.out.println("======keySet方法======");
        //第一种遍历方式
        Set<Student> keySet=map.keySet();
        Iterator<Student> it=keySet.iterator();
        while(it.hasNext()){
            Student stu=it.next();
            String add=map.get(stu);
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
        System.out.println("======entrySet方法======");
        //第二种遍历方式
        Set<Map.Entry<Student, String>> entrySet=map.entrySet();
        Iterator<Map.Entry<Student, String>> iter=entrySet.iterator();
        while(iter.hasNext()){
            Map.Entry<Student, String> student=iter.next();
            Student stu=student.getKey();
            String add=student.getValue();
            System.out.println(stu.getName()+"..."+stu.getAge()+"...."+add);
        }
    }

}
class StudentNameCom implements Comparator<Student>{

    @Override
    public int compare(Student stu1, Student stu2) {
        int num=stu1.getName().compareTo(stu2.getName());
        if(num==0){
            return new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
        }
        return num;
    }
    
}

 

 

四、TreeMap使用

 

4.1、示例

 

package com.pb.map.demo2;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/*
 * "sdfgzxcvasdfxcvdf"获取该字符串中的字母出次数
 * 1.使用map集合映射
 * 2.将字符中的字母做KEY，次数做value
 */
public class MapTest2 {

    public static void main(String[] args) {
        String str = "sdfgzxcvasdfxcvdf";
        TreeMap<String, Integer> map = getCount(str);
        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        while (it.hasNext()) {
            String s = it.next();
            Integer count = map.get(s);
            System.out.println(s + "...." + count);
        }

        String tmp = getCount2(str);
        System.out.println(tmp);
    }

    // 第一种
    public static TreeMap<String, Integer> getCount(String str) {
        TreeMap<String, Integer> map = new TreeMap<String, Integer>();

        for (int x = 0; x < str.length(); x++) {
            Set<String> keys = map.keySet();
            String s = str.substring(x, x + 1);
            if (keys.contains(s)) {
                Integer count = map.get(s);
                map.put(s, count + 1);
            } else {
                map.put(s, 1);
            }
        }

        return map;
    }

    // 第二种
public static String getCount2(String str){
    //转换为字符数组
    char[] chs=str.toCharArray();
    //定义TreeMap容器来存放
    TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
    //定义变量来存放次数
    int count=0;
    for(int x=0;x<chs.length;x++){
        if(!(chs[x]>=\'a\' &&chs[x]<=\'z\' || chs[x] >= \'A\'&&chs[x]<=\'Z\')){
            continue;
        }
        Integer value=tm.get(chs[x]);
        if(value!=null){
            count=value;
        }
        count++;
        tm.put(chs[x], count);
        count=0;
    }
    //声明变长sb对象
    StringBuilder sb=new StringBuilder();
    //获取Map.Entry对象
    Set<Map.Entry<Character, Integer>> entrySet=tm.entrySet();
    Iterator<Map.Entry<Character, Integer>> it=entrySet.iterator();
    //遍历添加
    while(it.hasNext()){
        Map.Entry<Character, Integer> m=it.next();
        Character c=m.getKey();
        Integer value=m.getValue();
        sb.append(c+"("+value+")");
    }
    return sb.toString();
    
}
}

 

结果：

 

a....1
c....2
d....3
f....3
g....1
s....2
v....2
x....2
z....1
a(1)c(2)d(3)f(3)g(1)s(2)v(2)x(2)z(1)

 

 

五、Map扩展

5.1、Map中嵌套Map或者集合

 

package com.pb.map.demo3;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

class Person{
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        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 class MapTest1 {

    public static void main(String[] args) {
        
        HashMap<String,ArrayList<Person>> map=new HashMap<String,ArrayList<Person>>();
        
        ArrayList<Person> persons1=new ArrayList<Person>();
        persons1.add(new Person("张三",33));
        persons1.add(new Person("李四",33));
        persons1.add(new Person("王五",33));
        ArrayList<Person> persons2=new ArrayList<Person>();
        persons2.add(new Person("赵六",33));
        persons2.add(new Person("钱七",33));
        persons2.add(new Person("刘八",33));
        
        
        map.put("SB001", persons1);
        map.put("SB002", persons2);
        
        
        Iterator<String> it=map.keySet().iterator();
        while(it.hasNext()){
            String room=it.next();
            System.out.println(room);
            ArrayList<Person> p=map.get(room);
            getInfos(p);
        }
        
        
    }
    
    public static void getInfos(ArrayList<Person> list){
        Iterator<Person> it=list.iterator();
        while(it.hasNext()){
            Person p=it.next();
            System.out.println(p.getName()+"..."+p.getAge());
        }
    }

}
//结果

SB001
张三...33
李四...33
王五...33
SB002
赵六...33
钱七...33
刘八...33

 

 

 

< 2018年1月 >
日	一	二	三	四	五	六
31	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31	1	2	3
4	5	6	7	8	9	10

 

常用链接

• 我的随笔
• 我的评论
• 我的参与
• 最新评论
• 我的标签

 

随笔分类(395)

• Ajax(1)
• Android(32)
• Android学习(25)
• Div+CSS(11)
• Eclipse使用(2)
• ExtJs
• Git
• Hibernate(15)
• html(2)
• HTML5(2)
• JAVA(12)
• Java Web基础(29)
• JavaScript(8)
• JAVA基础(51)
• JAVA入门(28)
• jQuery (1)
• Linux(13)
• Linux安装开发工具(6)
• Linux命令(18)
• Maven(1)
• MVC(1)
• MyBatis(7)
• MyEclipse使用(1)
• MySql(3)
• Oracle(34)
• PL/SQL(24)
• Python(6)
• Spring(13)
• Struts2(17)
• 工具(3)
• 面向对象设计(5)
• 软件工程(1)
• 数据结构和算法(1)
• 所遇到的错误(2)
• 网站优化和安全(5)
• 一些题(15)

随笔档案(397)

• 2016年9月 (7)
• 2016年8月 (15)
• 2016年7月 (7)
• 2016年3月 (20)
• 2016年2月 (5)
• 2015年11月 (9)
• 2015年10月 (12)
• 2015年9月 (43)
• 2015年8月 (3)
• 2015年6月 (2)
• 2015年5月 (5)
• 2015年4月 (50)
• 2015年3月 (42)
• 2015年2月 (84)
• 2015年1月 (93)

最新评论

• 1. Re:Oracle行列转换
• 不错，对于初学着很好
• --天涯流浪路
• 2. Re:分组统计查询(学习笔记)
• sql分组查询，统计，不错！
• --星雷热忱
• 3. Re:安卓学习-- RecyclerView简单入门
• 怎么实现多布局啊
• --绍良的帅气笔记
• 4. Re:JAVA中AES对称加密和解密
• @初升的月亮1是加密码，2是解密 public static final int ENCRYPT_MODE = 1; public static final int DECRYPT_MODE...........
• --森林森
• 5. Re:JAVA中AES对称加密和解密
• cipher.init(Cipher.ENCRYPT_MODE, key);这句话里面的Cipher.ENCRYPT_MODE改成1，像以下这样是什么意思cipher.init(1, skey);........
• --初升的月亮

阅读排行榜

• 1. JAVA中AES对称加密和解密(27982)
• 2. BeanFactory not initialized or already closed - call \'refresh\' before accessing beans解决办法(24162)
• 3. Maven学习——安装与修改Maven的本地仓库路径(19293)
• 4. Oracle行列转换(15232)
• 5. Python学习 windows下面安装Python和pip(一)(12955)

评论排行榜

• 1. Struts2(十七)验证框架二(6)
• 2. 文件的上传Commons FileUpload(web基础学习笔记十六)(3)
• 3. Java从零开始学三十二(正则表达式)(3)
• 4. 利用Session完成用户的登录和注销(3)
• 5. JAVA中AES对称加密和解密(3)

推荐排行榜

• 1. Tomcat环境的搭建(web基础学习笔记一)(5)
• 2. Android Studio安装使用图文教程(转)(5)
• 3. mybatis实战教程(mybatis in action),mybatis入门到精通(转)(5)
• 4. Oracle行列转换(4)
• 5. MyBatis入门（一）---基本使用(4)

 from：https://www.cnblogs.com/liunanjava/p/4839634.html