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

2021-10-15 03:37:09

一、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
上一篇：【Python全栈笔记】04 [模块二] 18 Oct lambda表达式， 内置函数


下一篇：tensor、numpy以及PIL的转换