首页 > 其他分享 >HashMap

HashMap

时间：2024-03-08 20:55:59浏览次数：22  
标签：HashMap System put map1 println out

HashMap

 Map集合继承体系:
        1、Map集合中的元素是一个键值对
        2、一个键对应一个值，键不允许重复，键是唯一的
        3、值可以发生重复
    子类：HashMap<K,V>

成员方法1：

        V remove(Object key)
        void clear()
        boolean containsKey(Object key)
        boolean containsValue(Object value)
        boolean isEmpty()
        int size()

V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();
        
        // V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
    }
}

这里第一行输出的是null，第三行输出的是小明，，对象的确添加进去了，说明这里返回的是被替代的对象的值

image-20240308192919360

V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();

        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
	// V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));  //根据key进行删除
        System.out.println(map1);  
    }
}

image-20240308193455098

若是给了一个不存在的key值，不会报错，会返回null值

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();
	// V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
	// V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));  //根据key进行删除
        System.out.println(map1);  
        System.out.println(map1.remove(1100));
        System.out.println(map1);
    }
}

image-20240308193717592

void clear() 清空

 
package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();
	// V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
	// V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));  //根据key进行删除
        System.out.println(map1);  
        System.out.println(map1.remove(1100));
        System.out.println(map1);
        System.out.println("=====================");
        //void clear()
        map1.clear();
        System.out.println(map1);
    }
}

image-20240308194223057

boolean containsKey(Object key) 是否包含这个Key值

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();

        //V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));
        System.out.println(map1);
        System.out.println(map1.remove(1100));
        System.out.println(map1);
        System.out.println("=====================");
        //void clear()
//        map1.clear();
//        System.out.println(map1);
        ////boolean containsKey(Object key)
        System.out.println(map1.containsKey(1003));
    }
}

image-20240308194722510

boolean containsValue(Object value) 是否包含这个Value值

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();

        //V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));
        System.out.println(map1);
        System.out.println(map1.remove(1100));
        System.out.println(map1);
        System.out.println("=====================");
        //void clear()
//        map1.clear();
//        System.out.println(map1);
        System.out.println("=====================");
        ////boolean containsKey(Object key)
        System.out.println(map1.containsKey(1003));
        System.out.println("=====================");
        //boolean containsValue(Object value)
        System.out.println(map1.containsValue("小花"));
    }
}

image-20240308194752000

boolean isEmpty() 判断是否是空

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();

        //V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));
        System.out.println(map1);
        System.out.println(map1.remove(1100));
        System.out.println(map1);
        System.out.println("=====================");
        //void clear()
//        map1.clear();
//        System.out.println(map1);
        System.out.println("=====================");
        ////boolean containsKey(Object key)
        System.out.println(map1.containsKey(1003));
        System.out.println("=====================");
        //boolean containsValue(Object value)
        System.out.println(map1.containsValue("小花"));
        System.out.println("=====================");
        //boolean isEmpty()
        System.out.println(map1.isEmpty());
    }
}

image-20240308194948805

int size() 获取元素个数，键值对的个数

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建HashMap的对象
        //HashMap()
        //构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）
        HashMap<Integer, String> map1 = new HashMap<>();

        //V put(K key,V value) 向集合中添加一个元素键值对，如果键已经存在集合中，值会进行覆盖处理，返回被覆盖的值
        //向map集合中添加一个键值对元素
        System.out.println(map1.put(1001,"小明"));
        System.out.println(map1);
        System.out.println("=====================");
        System.out.println(map1.put(1001,"小花"));
        System.out.println(map1);
        System.out.println("=====================");
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V remove(Object key) 根据键删除整个键值对，因为键是唯一的，返回键对应的值
        System.out.println(map1.remove(1001));
        System.out.println(map1);
        System.out.println(map1.remove(1100));
        System.out.println(map1);
        System.out.println("=====================");
        //void clear()
//        map1.clear();
//        System.out.println(map1);
        System.out.println("=====================");
        ////boolean containsKey(Object key)
        System.out.println(map1.containsKey(1003));
        System.out.println("=====================");
        //boolean containsValue(Object value)
        System.out.println(map1.containsValue("小花"));
        System.out.println("=====================");
        //boolean isEmpty()
        System.out.println(map1.isEmpty());
        System.out.println("=====================");
        //int size()  获取元素个数，键值对的个数
        System.out.println(map1.size());
    }
}

image-20240308195139367

成员方法2：

    V get(Object key)
    Set<K> keySet()
    Collection<V> values()
    Set<Map.Entry<K,V>> entrySet()

V get(Object key) 根据 键 获取 值

package com.shujia.day14;
import java.util.HashMap;

public class MapDemo2 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();

        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V get(Object key) 根据键获取值
        System.out.println(map1.get(1010));
    }
}

这里因为没有key值为1010的，所以返回的是null值

image-20240308195446011

Set keySet() 获取所有的 键 组成一个Set集合返回

package com.shujia.day14;
import java.util.HashMap;
import java.util.Set;

public class MapDemo2 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();

        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V get(Object key) 根据键获取值
        System.out.println(map1.get(1010));
        System.out.println("=====================");
        //Set<K> keySet() 获取所有的键组成一个Set集合返回
        Set<Integer> KeySet = map1.keySet();
        System.out.println(KeySet);
        System.out.println("=====================");
    }
}

image-20240308195933203

Collection values()

package com.shujia.day14;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class MapDemo2 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();

        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V get(Object key) 根据键获取值
        System.out.println(map1.get(1010));
        System.out.println("=====================");
        //Set<K> keySet() 获取所有的键组成一个Set集合返回
        Set<Integer> KeySet = map1.keySet();
        System.out.println(KeySet);
        System.out.println("=====================");
        //Collection<V> values()
        Collection<String> values = map1.values();
        System.out.println(values);
        System.out.println("=====================");
    }
}

image-20240308200048574

Collection values() 一次性获取所有的键值对

package com.shujia.day14;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo2 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();

        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //V get(Object key) 根据键获取值
        System.out.println(map1.get(1010));
        System.out.println("=====================");
        //Set<K> keySet() 获取所有的键组成一个Set集合返回
        Set<Integer> KeySet = map1.keySet();
        System.out.println(KeySet);
        System.out.println("=====================");
        //Collection<V> values()
        Collection<String> values = map1.values();
        System.out.println(values);
        System.out.println("=====================");
        //Set<Map.Entry<K,V>> entrySet()   一次性获取所有的键值对
        Set<Map.Entry<Integer, String>> entries = map1.entrySet();
        System.out.println(entries);
    }
}

image-20240308200259890

Map集合遍历的方式：

1、先获取所有的键，遍历键获取对应的值

package com.shujia.day14;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

public class MapDemo3 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //获取所有的键
        Set<Integer> keySet = map1.keySet();
        for (Integer key:keySet){
            //根据键获取对应的值
            String value = map1.get(key);
            System.out.println(key+"---"+value);
        }
    }
}

image-20240308201021744

2、直接获取所有的键值对，遍历每一个键值对，就能够得到每一个键和值

package com.shujia.day14;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo4 {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1002,"小红");
        map1.put(1003,"小王");
        map1.put(1004,"小李");
        map1.put(1005,"小白");
        System.out.println(map1);
        System.out.println("=====================");
        //先获取所有的键值对，再进行赋值
        Set<Map.Entry<Integer, String>> keyValues = map1.entrySet();
        for (Map.Entry<Integer, String> keyValue : keyValues) {
            Integer key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key+"---"+value);
        }
    }
}

image-20240308201354003

练习

先创建一个Student1类

package com.shujia.day14;

import java.util.Objects;


public class Student1{
        private String name;
        private int age;

        public Student1() {
        }

        public Student1(String name, int age) {
            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;
        }

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

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

        @Override
        public String toString() {
            return "Student1{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

//    @Override
//    public int compareTo(Student1 o) {
//        //按照年龄从小到大排序
//        int i1 = this.getAge() - o.getAge();
//        //隐藏条件：年龄一样的时候，姓名不一定一样
//        return (i1 == 0) ? this.getName().compareTo(o.getName()) : i1;
//    }

}

package com.shujia.day14;

import java.util.Objects;


public class Student1{
        private String name;
        private int age;

        public Student1() {
        }

        public Student1(String name, int age) {
            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;
        }

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

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

        @Override
        public String toString() {
            return "Student1{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

//    @Override
//    public int compareTo(Student1 o) {
//        //按照年龄从小到大排序
//        int i1 = this.getAge() - o.getAge();
//        //隐藏条件：年龄一样的时候，姓名不一定一样
//        return (i1 == 0) ? this.getName().compareTo(o.getName()) : i1;
//    }

}


package com.shujia.day14;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/*
    根据昨天HashSet中add方法实际上就是调用今天要讲的HashMap中的put方法，要想保证HashMap中的键唯一
    根据分析得出，键的类型要重写hashCode()方法和equals方法

    HashMap<Student,String> 当学生的姓名和年龄一样的时候，认为是同一个学生

 */
public class HashMapDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        HashMap<Student1, String> map1 = new HashMap<Student1, String>();

        //创建元素对象
        Student1 s1 = new Student1("小红", 16);
        Student1 s2 = new Student1("小红2", 15);
        Student1 s3 = new Student1("小红3", 18);
        Student1 s4 = new Student1("小红4", 19);
        Student1 s5 = new Student1("小红", 16);

        //向集合中添加元素
        map1.put(s1, "打篮球");
        map1.put(s2, "踢足球");
        map1.put(s3, "打排球");
        map1.put(s4, "打台球");
        map1.put(s5, "打羽毛球");

        //遍历集合
        Set<Map.Entry<Student1, String>> entries = map1.entrySet();
        for (Map.Entry<Student1, String> entry : entries) {
            Student1 key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"---"+value);
        }

    }
}

image-20240308205101767

LinkedHashMap

LinkedHashMap:底层数据结构是哈希表和双链表

取出的顺序与添加的顺序一致

package com.shujia.day14;
import java.util.LinkedHashMap;
/*
    LinkedHashMap:底层数据结构是哈希表和双链表
    取出的顺序与添加的顺序一致
 */
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map1 = new LinkedHashMap<>();
        map1.put("1001","shujia1");
        map1.put("1002","shujia2");
        map1.put("1003","shujia3");
        map1.put("1002","shujia4");
        map1.put("1007","shujia5");
        map1.put("1005","shujia6");
        map1.put("1004","shujia7");

        System.out.println(map1);
    }
}

image-20240308205433164

标签：HashMap,System,put,map1,println,out
From： https://www.cnblogs.com/peculiar/p/18061842

相关文章

  • HashMap对value的遍历
    1、Iterator遍历 Map<Integer,String>map=newHashMap<>();    Iterator<String>iterator=map.values().iterator();    while(iterator.hasNext()){      Stringvalues=iterator.next();    } 2、直接循环HashMap<Integ......
  • 什么是ConcurrentHashMap?不同JDK下ConcurrentHashMap的区别？
    什么是ConcurrentHashMap?不同JDK下ConcurrentHashMap的区别？  一、HashMap线程安全  我们知道，在并发情况下，使用HashMap会有线程安全的问题，那么如何避免呢？  想要避免Hashmap的线程安全问题有很多办法，比如改用HashTable或者Collections.synchronizedMap  但是，这两者......
  • 接口测试-json文件读取报java.lang.ClassCastException: java.util.LinkedHashMap can
    问题原因：从json文件中读取的信息为hashMap，与预期（类对象）格式不匹配，无法解析。问题分析：json文件包含一个json串列表，代表向接口中传递不同的参数组合，通过下面方法读取json文件信息，反序列化成类对象，并把这些赋值的对象进行接口请求参数进行传递。publicList<T>getReadValuesLi......
  • 手写HashMap基础部分代码
    代码展示：packagecom.north.hashmap;importjava.util.Map;/***@AuthorNorth*@Date2024/3/3*手写HashMap*/@SuppressWarnings("all")publicclassMyHashMap<K,V>{/***哈希表*/privateNode<K,V>[]table;......
  • 关于HashMap遍历的四种方式，以及为什么要用entry
    1.问题如何遍历HashMap，以及其中一种遍历方式中，我们为何需要先转为Map.Entry后，再遍历Map呢？而且是比较推荐的方式？2.解决参考：关于HashMap遍历，为什么要用entryHashMap中推荐使用entrySet方式遍历Map类集合KV而不是keySet方式遍历2.1为何使用Map.Entry阅读《阿里巴巴Java开发手......
  • 为什么HashMap的键值可以为null，而ConcurrentHashMap不行？
    写在开头昨天在写《HashMap很美好，但线程不安全怎么办？ConcurrentHashMap告诉你答案！》这篇文章的时候，漏了一个知识点，直到晚上吃饭的时候才突然想到，关于ConcurrentHashMap在存储Key与Value的时候，是否可以存null的问题，按理说这是一个小问题，但build哥却不敢忽视，尤其在现在很多面试官都......
  • HashMap很美好，但线程不安全怎么办？ConcurrentHashMap告诉你答案！
    写在开头在《耗时2天，写完HashMap》这篇文章中，我们提到关于HashMap线程不安全的问题，主要存在如下3点风险：风险1：put的时候导致元素丢失；如两个线程同时put，且key值相同的情况下，后一个线程put操作覆盖了前一个线程的操作，导致前一个线程的元素丢失。风险2：put和get并发时会导致g......
  • 面试官上来就让手撕HashMap的7种遍历方式，当场愣住，最后只写出了3种
    写在开头今天有个小伙伴私信诉苦，说面试官上来就让他手撕HashMap的7种遍历方式，最终只写出3种常用的，怀疑面试官是在故意***难。这个问题大家怎么看？反正我个人感觉这肯定不是***难，“手撕遍历方式”算是一个比较简单的考验方式了，而且集合的遍历又是日常开发的必备！至于要一下写出7......
  • JUC系列之（四）ConcurrentHashMap锁分段机制
    ConcurrentHashMap锁分段机制1.关于HashMap和HashTableHashMap：线程不安全HashTable：效率低：操作时锁整个表复合操作会带来安全问题//table.contains()和table.put()分别都是加了锁的，但是像下述复合操作，一个线程判断完之后CPU可能被其他线程抢夺，带来安全问题if(!table.c......
  • Java HashMap 详解
    HashMapHashMap继承自AbstractMap，实现了Map接口，基于哈希表实现，元素以键值对的方式存储，允许键和值为null。因为key不允许重复，因此只能有一个键为null。HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不相同。HashMap是线程不安全的。1.哈希表哈希表基于数......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99