Java Map集合與Collection類的使用詳解

更新時間：2022年11月25日 08:30:10 作者：芝麻干

這篇文章主要介紹了Java Map集合的使用及Collection工具類使用，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習吧

Map接口

Map接口的特點

1. 用于存儲任意鍵值對（key - value）

2. 鍵：無序、無下標、不允許重復(fù)（唯一）

3. 值：無序、無下標、允許重復(fù)

Map集合中的方法：

1. V put(K key, V value) 將對象存到集合中，關(guān)聯(lián)鍵值

2. Object get(Object key) 根據(jù)鍵獲得對應(yīng)的值

3. Set<K> 返回所有的Key

4. Collection<V> values() 返回包含所有值的Collection集合

5. Set<Map.Entry<K, V>> 鍵值匹配的Set集合

Map接口的使用：

package com.collections.map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
 * Map父接口的使用
 * 特點：（1）存儲鍵值對（2）鍵不能重復(fù)，值可以重復(fù)（3）無序
 */
public class Demo01 {
    public static void main(String[] args) {
//        創(chuàng)建Map集合
//        添加 鍵不可重復(fù)
        Map<String,String> map = new HashMap<>();
        map.put("CN","中國");
        map.put("USA","美國");
        map.put("UN","英國");
        map.put("CN","zhongguo");
        map.put("ZH","中國");
        System.out.println("元素個數(shù)："+map.size());
        System.out.println(map.toString());
//        刪除 用鍵刪除
        map.remove("CN");
        System.out.println("刪除后："+map.size());
//        3.遍歷
//        3.1使用keySet
//        把map的鍵key轉(zhuǎn)成Set集合，再用Set集合的遍歷方法遍歷出來
        System.out.println("--------3.1使用keySet-------");
//        Set<String> strings = map.keySet();
        for (String key:map.keySet()) {
            System.out.println(key+":"+map.get(key));//map.get(key) 取出map集合中對應(yīng)key的值
        }
//        3.2使用entrySet
//        把map的鍵和值放進Entry映射對中并放進Set集合，再用Set集合的遍歷方法遍歷出來
        System.out.println("----------3.2使用entrySet---------");
//        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry:map.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
//        4.判斷
        System.out.println(map.containsKey("CN"));
        System.out.println(map.containsValue("中國"));
    }
}

遍歷可以用keySet和entrySet。

運行結(jié)果：

HashMap

存儲結(jié)構(gòu)：哈希表（數(shù)組+鏈表+紅黑樹）

使用key可使hashcode和equals作為重復(fù)

HashMap的使用：

package com.collections.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
 * HashMap集合的使用
 * 存儲結(jié)構(gòu)：哈希表（數(shù)組+鏈表+紅黑樹）
 */
public class Demo02 {
    public static void main(String[] args) {
//        創(chuàng)建集合
//        剛創(chuàng)建HashMap時，table=null,size=0 目的：節(jié)省空間
//        添加第一個元素的時候，table=16, size=16*0.75=12
//        當元素個數(shù)超過閾值12時，會進行擴容，每次擴容時原來的兩倍
        HashMap<Student,String> students = new HashMap<>();
//        添加元素
        Student s1 = new Student("孫悟空",100);
        Student s2 = new Student("豬八戒",101);
        Student s3 = new Student("沙和尚",102);
        students.put(s1,"北京");
        students.put(s2,"上海");
        students.put(s3,"杭州");
//        鍵不可重復(fù)，鍵重復(fù)了值會被替換掉,不存在新增操作
//        students.put(s3,"西安");
        students.put(new Student("沙和尚",102),"南京");
        System.out.println("元素個數(shù)"+students.size());
        System.out.println(students.toString());
//        遍歷
//        1.KeySet
        System.out.println("--------------KeySet----------------");
        Set<Student> students1 = students.keySet();
        for (Student key: students1) {
            System.out.println(key+":"+students.get(key));
        }
//        2.entrySet
        System.out.println("------------entrySet------------------------");
        Set<Map.Entry<Student, String>> entries = students.entrySet();
        Iterator<Map.Entry<Student, String>> iterator = entries.iterator();
       while (iterator.hasNext()){
           Map.Entry<Student, String> key = iterator.next();
           System.out.println(key);
       }
    }
}

Student類：

package com.collections.map;
import java.util.Objects;
public class Student {
    private String name;
    private  int stuNo;
    public Student() {
    }
    public Student(String name, int stuNo) {
        this.name = name;
        this.stuNo = stuNo;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getStuNo() {
        return stuNo;
    }
    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", stuNo=" + stuNo +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return stuNo == student.stuNo &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, stuNo);
    }
}

運行結(jié)果：

使用方法增、刪、遍歷、判斷與上述一致

HashMap原碼分析總結(jié)：

HashMap剛創(chuàng)建時，table是null，節(jié)省空間，當添加第一個元素時，table容量調(diào)整為16
當元素個數(shù)大于閾值（16*0.75 = 12）時，會進行擴容，擴容后的大小為原來的兩倍，目的是減少調(diào)整元素的個數(shù)
jdk1.8 當每個鏈表長度 >8 ，并且數(shù)組元素個數(shù) ≥64時，會調(diào)整成紅黑樹，目的是提高效率
jdk1.8 當鏈表長度 <6 時調(diào)整成鏈表
jdk1.8 以前，鏈表時頭插入，之后為尾插入

Hashtable和Properties：

Hashtable線程安全，運行效率慢；不允許null作為key或是value。

Properties是hashtable的子類，要求key和value都是string，通常用于配置文件的讀取。

TreeMap：

使用方式參考TreeSet：必須實現(xiàn)Comparable接口或者使用Compator比較器。

package com.collections.map;
import java.util.Comparator;
import java.util.TreeSet;
/**
 * TreeSet的使用
 */
public class Demo03 {
    public static void main(String[] args) {
        TreeSet<Student> treeSet =  new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int n1 = o1.getStuNo()-o2.getStuNo();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });
        Student s1 = new Student("孫悟空",100);
        Student s2 = new Student("豬八戒",101);
        Student s3 = new Student("沙和尚",102);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        System.out.println(treeSet.toString());
    }
}

Student類：

package com.collections.map;
import java.util.Objects;
public class Student {
    private String name;
    private  int stuNo;
    public Student() {
    }
    public Student(String name, int stuNo) {
        this.name = name;
        this.stuNo = stuNo;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getStuNo() {
        return stuNo;
    }
    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", stuNo=" + stuNo +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return stuNo == student.stuNo &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, stuNo);
    }
}

運行結(jié)果：

使用方法和上面一致。

Collection工具類：

概念：集合工具類，定義了除了存取以外的集合常用方法

直接二分查找int i = Collections.binarySearch(list, x);成功返回索引、copy復(fù)制、reverse反轉(zhuǎn)、shuffle打亂

其他方法：數(shù)組轉(zhuǎn)成集合、集合轉(zhuǎn)成數(shù)組

package com.collections;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
 * Collections類的使用
 */
public class Demo02 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(5);
        list.add(20);
        list.add(60);
        list.add(1);
//        sort 排序
        System.out.println("排序之前"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后"+list.toString());
//        copy復(fù)制
        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i <list.size() ; i++) {
            arrayList.add(0);
        }
        Collections.copy(arrayList,list);
        System.out.println(arrayList.toString());
//        reverse反轉(zhuǎn)
        Collections.reverse(arrayList);
        System.out.println(arrayList.toString());
//        shuffle 打亂
        Collections.shuffle(arrayList);
        System.out.println(arrayList.toString());
//        補充：集合轉(zhuǎn)成數(shù)組
        Integer[] integer = list.toArray(new Integer[0]);
        System.out.println(integer.length);
        System.out.println(Arrays.toString(integer));
//        數(shù)組轉(zhuǎn)成集合
//        創(chuàng)建出來的集合是一個受限集合，無法添加和刪除元素
        String [] s = {"張三","李四","王五","趙六",};
        List<String> strings = Arrays.asList(s);
        System.out.println(strings);
//        還要注意int類型的數(shù)組轉(zhuǎn)出的集合最好是Integer類型，否則就是int[]數(shù)組類型了
        Integer[] i = {100,200,300,400};
        List<Integer> ints = Arrays.asList(i);
        System.out.println(ints);
    }
}

運行結(jié)果：