Java中的Map集合

Map

1、Map常用得子类
HashMap<k,v>：储存数据采用得哈希表结构，元素存取顺序不能保证一致，由于要保证键的唯一、不重复，需要键的 hashCode、equals方法；
LinkedHashMap<k,v>：HashMap 下的子类 LinkHashMap ，确保其元素存取顺序一致
需要注意的是，在Map 中不能包含重复的键，值是可以重复的

Map常用方法

import java.util.HashMap;

public class MapTestDemo {
    public static void main(String[] args){
        //创建一个Map对象，相当字典
        HashMap<String,Integer>  maplist = new HashMap<>();

        //put(k，v) ：添加元素到集合中
        maplist.put("小红",12);
        maplist.put("小明",9);
        maplist.put("小东",11);
        System.out.println(maplist); //{小明=9, 小东=11, 小红=12}

        //remove(key) 移除指定的键对应的键值对
        maplist.remove("小明");
        System.out.println(maplist);  //{小东=11, 小红=12}

        //get(key) 根据指定的键返回对应的值
        System.out.println(maplist.get("小红")); //12

        //containskey(key) 判断集合是否包含指定的键
        System.out.println(maplist.containsKey("小东")); //true

        //set<k> keySet() 将集合中的所有键存储到Set集合中
        System.out.println(maplist.keySet()); //[小东, 小红]

    }
}

输出：

2、遍历Map集合键值对

public class MapTestTwo {
    public static void main(String[] args){
        HashMap<String,Integer> maplist = new HashMap<>();
		//put(key,value) 添加元素
        maplist.put("Bob",12); 
        maplist.put("Alice",13);
        maplist.put("Tom",10);

        Set<String> set = maplist.keySet(); //将获取的key 存入 set 集合中
        for(String key :set){
            int value = maplist.get(key); //使用get(key)获取值
            System.out.println(key + " : " + value);
        }
    }
}

输出：

3、Entry 键值对对象
从上面的笔记已经知道，Map集合中存放两种对象，键（key）与值（value），他们是一一对应的关系，这种对象又称作Map 种的一个Entry（项），Entry 将键值对的对应关系封装成了对象，即键值对对象，在遍历 Map 集合时，就可以从每一个键值对（Entry）对象种获取对应得键与对应得值，那么在 Entry 种对应得键值方法：getKey() 获取Entry 对象中的键，getValue() 获取值
在map 中提供方法：

Set<Map.Entry<k,v>> entrySet（）：获取Map集合中所有的键值对对象的集合（Set集合）

a. 获取 Map 中的 Entry 对象，是以 Set 集合形式返回的，方法：entrySet().

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class mapEntryDemoOne {
    public static void main(String[] args){
        //创建按map集合
        Map<String,String> maplist = new HashMap<>();
       
        maplist.put("林冲","豹子头");
        maplist.put("马云","阿里");
        maplist.put("马化腾","qq");
        //获取所有entry对象
        Set<Map.Entry<String,String>> entryset = maplist.entrySet();
        //遍历键值对
        for(Map.Entry<String,String> entry : entryset){
            String key = entry.getKey(); 
            String value = entry.getValue();
            System.out.println(key + " : " + value);
        }
    }
}

3、HashMap 存储自定类型的键值的例子,需要多写看源码来理解,本人不是很熟；下面需要注意的是还需要重写 toString 方法，这样输出时才会正常

package Demooen;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Objects;

public class HashMapEntry {
    public static void main(String[] args){
        //创建集合对象
        HashSet<studentClass> student = new HashSet<>();
        //储存
        studentClass stu = new studentClass();
        
        student.add(new studentClass("小明",12));
        student.add(new studentClass("小东",13));
        student.add(new studentClass("小明",12));
        student.add(new studentClass("小红",10));

        for (studentClass stuone : student){
            System.out.println(stuone);
        }
    }
}
class studentClass{
    private String name;
    private int age;

    public studentClass(){
    }

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

    public String getName(){
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge(){
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //重写equals方法
    @Override
    public boolean equals(Object o){
        if(this == o)
            return true;
        if(o == null || getClass() != o.getClass())
            return false;
        studentClass students = (studentClass) o; //向下转型
        return age == students.age && Objects.equals(name, students.name);
    }
    //重写hashcode 方法
    @Override
    public int hashCode(){
        return Objects.hash(name,age);
    }
    //重写toString 方法,不然打印不出来
    @Override
    public String toString(){
        return name + " " + age;
    }
}

输出:

4、LinkedHashMap
hashMap 是保证成对的元素唯一,查询时较快,但是其存放是没有顺序的,若要快又有顺序的,那么就需要使用 LinkedHashMap ,他是HashMap下的子类

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

public class LinkedHashMampDemoOne {
    public static void main(String[] args){
        //创建linkHashMap 对象
        LinkedHashMap<String,Integer> linkhash = new LinkedHashMap<>();

        linkhash.put("小明",9);
        linkhash.put("小红",10);
        linkhash.put("小东",12);
        //创建 Entry 键值对对象
        Set<Map.Entry<String,Integer>> entrylink = linkhash.entrySet();
        //通过 Entry 对象遍历
        for(Map.Entry<String,Integer> linkmap : entrylink){
            String key = linkmap.getKey();
            int value = linkmap.getValue();
            System.out.println(key + " "+ value);
        }
    }
}

输出:

练习：计算输入的字母中字母出现的次数

import java.util.HashMap;
import java.util.Scanner;
public class PracticemapDemo {
    public static void main(String[] args){
        System.out.println("请输入一串字符： ");
        Scanner inputstr = new Scanner(System.in);
        String str = inputstr.next();
        findstrissng(str);
    }

    public static void findstrissng(String str){
        //创建hashmap 集合对象
        HashMap<Character, Integer> hmap = new HashMap<>();
        //遍历字符串
        for(int i=0; i < str.length(); i++){
            char sc = str.charAt(i);
            //判断是否存在键集合中
            if(!hmap.containsKey(sc)){
                hmap.put(sc, 1);
            }
            else{
                //获取之前的次数
                Integer count = hmap.get(sc);
                hmap.put(sc,++count);
            }
            System.out.println(hmap);
        }
        System.out.println(hmap);
    }
}

输出：

注意: i++ 与 ++i 的区别

i++ : 先进行表达运算（如赋值），再自增
++i : 先自增，再进行表达式运算（如赋值）

i++

public class ajaja {
	public static void main(String[] args) {
		int a = 0;
		for(int i=0; i<99; i++) {
		//a先将值赋给 a（之后a为0），再进行自增，但是自增后并未执行赋值操作，所以a还是为0，无论多次进行循环a 都是 0
			a = a++;
		}		System.out.println(a); //0
	}
}

输出

++i

public class jajaa {
	public static void main(String[] args) {		
		int a = 0;
		for(int i=0; i<99; i++) {
		//a先自增为1,然后再进行赋值给 a; 此时a 为1, 依次累计,直到循环完毕
			a = ++a;
		}
		System.out.println(a); //99
	}
}

输出：