集合之比较接口器+Map家族的HashMap+LinkedHashMap+Hashtable+ConcurrentHashMap

最新推荐文章于 2024-10-17 10:27:13 发布
最新推荐文章于 2024-10-17 10:27:13 发布
阅读量182 收藏
点赞数 1
分类专栏： Java基础 文章标签： java spring jvm 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gl280599zl/article/details/127345843
版权

集合之比较接口器+Map家族的HashMap+LinkedHashMap+Hashtable+ConcurrentHashMap

一、比较器接口

1.内置比较器 – Comparable

import java.util.TreeSet;

public class Test03 {
	public static void main(String[] args) {
		
		TreeSet<Student> set = new TreeSet<>();
		
		set.add(new Student("孙尚香", '女', 22, "2211", "001"));     
		set.add(new Student("安吉拉", '女', 25, "2211", "002"));     
		set.add(new Student("虞姬", '女', 19, "2211", "003"));     
		set.add(new Student("妲己", '女', 29, "2211", "004"));     
		set.add(new Student("杨贵妃", '女', 21, "2211", "005"));    
		set.add(new Student("钟无艳", '女', 20, "2211", "006"));    
		set.add(new Student("貂蝉", '女', 19, "2211", "007"));    
		set.add(new Student("大桥", '女', 18, "2211", "008"));    
		set.add(new Student("伽罗", '女', 21, "2211", "009"));    
		set.add(new Student("黄忠", '男', 25, "2211", "010"));     
		set.add(new Student("小乔", '女', 22, "2212", "001"));    
		set.add(new Student("阿珂", '女', 24, "2212", "002"));    
		set.add(new Student("瑶", '女', 20, "2212", "003"));   
		set.add(new Student("上官婉儿", '女', 22, "2212", "004"));  
		set.add(new Student("墨瞳茉拉", '女', 22, "2213", "004"));  
		
		for (Student stu : set) {
			System.out.println(stu);
		}
		
	} 
}

public class Student implements Comparable<Student> {

	private String name;
	private char sex;
	private int age;
	private String classId;
	private String id;
	
	public Student() {
		
	}

	
	public Student(String classId, String id) {
		this.classId = classId;
		this.id = id;
	}


	public Student(String name, char sex, int age, String classId, String id) {
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.classId = classId;
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getClassId() {
		return classId;
	}

	public void setClassId(String classId) {
		this.classId = classId;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	@Override
	public String toString() {
		return name + "\t" + sex + "\t" + age + "\t" + classId + "\t" + id;
	}

	//判断两个学生是否相同（班级号 + 学号）
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		
		if (obj instanceof Student) {
			Student stu = (Student) obj;
			if (classId.equals(stu.classId) && id.equals(stu.id)) {
				return true;
			}
		}
		return false;
	}
	//排序规则：按照年龄排序
	@Override
	public int compareTo(Student o) {
		//年龄差
		int num = this.age - o.age;
		if (num != 0) {
			return num;
		}
		
		if (this == o || this.equals(o)) {
			return 0;
		}
		//年龄相同，但是两个学生又不是同一个对象，我们还是返回1
		return 1;
	}
}

2.外置比较器 – Comparator

1.应用场景：
需求：按照名字长度排序，长度一致按照年龄排序
2.比较器优先级别：外置比较器 > 内置比较器
import java.util.Comparator;
import java.util.TreeSet;

public class Test04 {

	public static void main(String[] args) {
		TreeSet<Student> set = new TreeSet<>(new Comparator<Student>(){

			@Override
			public int compare(Student o1, Student o2) {
			if (o1 == o2 || o1.equals(o2)) {
				return 0;
			}
			int len1 = o1.getName().length();
			int len2 = o2.getName().length();
			if (len1 != len2) {
				return len1 - len2;
			}
			int age1 = o1.getAge();
			int age2 = o2.getAge();
			if (age1 != age2) {
				return age1 - age2;
			}
				return 1;
			}
			
			});
		
		set.add(new Student("孙尚香", '女', 22, "2211", "001"));     
		set.add(new Student("安吉拉", '女', 25, "2211", "002"));     
		set.add(new Student("虞姬", '女', 19, "2211", "003"));     
		set.add(new Student("妲己", '女', 29, "2211", "004"));     
		set.add(new Student("杨贵妃", '女', 21, "2211", "005"));    
		set.add(new Student("钟无艳", '女', 20, "2211", "006"));    
		set.add(new Student("貂蝉", '女', 19, "2211", "007"));    
		set.add(new Student("大桥", '女', 18, "2211", "008"));    
		set.add(new Student("伽罗", '女', 21, "2211", "009"));    
		set.add(new Student("黄忠", '男', 25, "2211", "010"));     
		set.add(new Student("小乔", '女', 22, "2212", "001"));    
		set.add(new Student("阿珂", '女', 24, "2212", "002"));    
		set.add(new Student("瑶", '女', 20, "2212", "003"));   
		set.add(new Student("上官婉儿", '女', 22, "2212", "004"));  
		set.add(new Student("墨瞳茉拉", '女', 22, "2213", "004"));  
		
		for (Student stu : set) {
			System.out.println(stu);
		}
	}
}

3.扩展

1.内置比较器：对象要想存入TreeSet、TreeMap中，对象所属的类必须要实现内置比较器
2.外置比较器：当内置比较的规则不满足现在的需求，但又不能改动内置比较器规则时

二、Map家族的HashMap

1.HashMap的使用

2.特点：key是唯一的

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
import java.util.Map.Entry;

public class Test01 {

	public static void main(String[] args) {
		
		HashMap<String, Integer> map = new HashMap<>();
		
		//添加元素 -- 如果key是第一次添加，则返回null
		Integer  put1 = map.put("大桥",18);
		Integer  put2 = map.put("小乔",19);
		Integer  put3 = map.put("西施",25);
		Integer  put4 = map.put("王昭君",20);
		Integer  put5 = map.put("杨贵妃",23);
		Integer  put6 = map.put("貂蝉",28);
		
		System.out.println("put()的返回值：" + put1);
		System.out.println("put()的返回值：" + put2);
		System.out.println("put()的返回值：" + put3);
		System.out.println("put()的返回值：" + put4);
		System.out.println("put()的返回值：" + put5);
		System.out.println("put()的返回值：" + put6);
		
		//替换元素，返回被替换掉的值
		Integer put = map.put("大桥", 20);
		System.out.println("put()的返回值：" + put);
		
		//替换元素，返回被替换掉的值
		Integer replace = map.replace("大桥", 21);
		System.out.println("replace()的返回值" + replace);
		
		//替换元素，返回是否替换成功的boolean
		boolean bool = map.replace("西施", 25,23);
		System.out.println("替换元素，返回是否替换成功的boolean：" + bool);
		
		//清空所有元素
		//map.clear();
		
		System.out.println("判断map中是否有指定的key：" + map.containsKey("小乔"));//true
		System.out.println("判断map中是否有指定的value：" + map.containsValue(28));//true
		
		//获取指定key对应的value
		Integer integer = map.get("西施");
		System.out.println("获取指定Key对应 的value：" + integer);//23

		//获取指定key对应的value，如果没key，就返回默认值
		Integer orDefault = map.getOrDefault("貂蝉111", 666);
		System.out.println("获取指定key对应的value：" + orDefault);//666

		System.out.println("判断map集合中是否不包含元素：" + map.isEmpty());//false

		//将newMap中所有的元素都添加到map中
		HashMap<String, Integer> newMap = new HashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		map.putAll(newMap);

		//如果map中没有该key就添加，如果有就返回对应的value
		Integer putIfAbsent = map.putIfAbsent("ddd", 40);
		System.out.println("如果map中没有该key就添加，如果有就返回对应的value：" + putIfAbsent);

		//根据key删除映射关系
		map.remove("杨贵妃");
		//根据key+value删除映射关系
		map.remove("ccc", 30);

		System.out.println("获取map中映射关系的个数：" + map.size());//8

		//获取map中所有的value，返回集合
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));

		System.out.println("---------------");

		//遍历方式1 -- keySet()
		//思路：获取map中所有的key，将key存放在set集合中，遍历set集合将key取出，
		//就可以通过map获取key对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + "---" + value);
		}
		
		System.out.println("---------------");
		
		//遍历方式2 -- entrySet()
		//entry：表示映射关系（key + value）
		//思路：获取map中所有的映射关系对象，将映射关系对象存放在set集合中，遍历set集合将映射关系对象取出，
		//就可以通过映射关系对象获取到key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

三、LinkedHashMap

1.LinkedHashMap的使用

2.特点：key是唯一的

import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Map.Entry;

public class Test01 {

	public static void main(String[] args) {
		
		LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
		
		//添加元素 -- 如果key是第一次添加，则返回null
		Integer  put1 = map.put("大桥",18);
		Integer  put2 = map.put("小乔",19);
		Integer  put3 = map.put("西施",25);
		Integer  put4 = map.put("王昭君",20);
		Integer  put5 = map.put("杨贵妃",23);
		Integer  put6 = map.put("貂蝉",28);
		
		System.out.println("put()的返回值：" + put1);
		System.out.println("put()的返回值：" + put2);
		System.out.println("put()的返回值：" + put3);
		System.out.println("put()的返回值：" + put4);
		System.out.println("put()的返回值：" + put5);
		System.out.println("put()的返回值：" + put6);
		
		//替换元素，返回被替换掉的值
		Integer put = map.put("大桥", 20);
		System.out.println("put()的返回值：" + put);
		
		//替换元素，返回被替换掉的值
		Integer replace = map.replace("大桥", 21);
		System.out.println("replace()的返回值" + replace);
		
		//替换元素，返回是否替换成功的boolean
		boolean bool = map.replace("西施", 25,23);
		System.out.println("替换元素，返回是否替换成功的boolean：" + bool);
		
		//清空所有元素
		//map.clear();
		
		System.out.println("判断map中是否有指定的key：" + map.containsKey("小乔"));//true
		System.out.println("判断map中是否有指定的value：" + map.containsValue(28));//true
		
		//获取指定key对应的value
		Integer integer = map.get("西施");
		System.out.println("获取指定Key对应 的value：" + integer);//23

		//获取指定key对应的value，如果没key，就返回默认值
		Integer orDefault = map.getOrDefault("貂蝉111", 666);
		System.out.println("获取指定key对应的value：" + orDefault);//666

		System.out.println("判断map集合中是否不包含元素：" + map.isEmpty());//false

		//将newMap中所有的元素都添加到map中
		LinkedHashMap<String, Integer> newMap = new LinkedHashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		map.putAll(newMap);

		//如果map中没有该key就添加，如果有就返回对应的value
		Integer putIfAbsent = map.putIfAbsent("ddd", 40);
		System.out.println("如果map中没有该key就添加，如果有就返回对应的value：" + putIfAbsent);

		//根据key删除映射关系
		map.remove("杨贵妃");
		//根据key+value删除映射关系
		map.remove("ccc", 30);

		System.out.println("获取map中映射关系的个数：" + map.size());//8

		//获取map中所有的value，返回集合
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));

		System.out.println("---------------");

		//遍历方式1 -- keySet()
		//思路：获取map中所有的key，将key存放在set集合中，遍历set集合将key取出，
		//就可以通过map获取key对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + "---" + value);
		}
		
		System.out.println("---------------");
		
		//遍历方式2 -- entrySet()
		//entry：表示映射关系（key + value）
		//思路：获取map中所有的映射关系对象，将映射关系对象存放在set集合中，遍历set集合将映射关系对象取出，
		//就可以通过映射关系对象获取到key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

四、Hashtable

1.Hashtable的使用

2.key是唯一的

import java.util.Arrays;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Set;
import java.util.Map.Entry;

public class Test01 {

	public static void main(String[] args) {
		
		Hashtable<String, Integer> map = new Hashtable<>();
		
		//添加元素 -- 如果key是第一次添加，则返回null
		Integer  put1 = map.put("大桥",18);
		Integer  put2 = map.put("小乔",19);
		Integer  put3 = map.put("西施",25);
		Integer  put4 = map.put("王昭君",20);
		Integer  put5 = map.put("杨贵妃",23);
		Integer  put6 = map.put("貂蝉",28);
		
		System.out.println("put()的返回值：" + put1);
		System.out.println("put()的返回值：" + put2);
		System.out.println("put()的返回值：" + put3);
		System.out.println("put()的返回值：" + put4);
		System.out.println("put()的返回值：" + put5);
		System.out.println("put()的返回值：" + put6);
		
		//替换元素，返回被替换掉的值
		Integer put = map.put("大桥", 20);
		System.out.println("put()的返回值：" + put);
		
		//替换元素，返回被替换掉的值
		Integer replace = map.replace("大桥", 21);
		System.out.println("replace()的返回值" + replace);
		
		//替换元素，返回是否替换成功的boolean
		boolean bool = map.replace("西施", 25,23);
		System.out.println("替换元素，返回是否替换成功的boolean：" + bool);
		
		//清空所有元素
		//map.clear();
		
		System.out.println("判断map中是否有指定的key：" + map.containsKey("小乔"));//true
		System.out.println("判断map中是否有指定的value：" + map.containsValue(28));//true
		
		//获取指定key对应的value
		Integer integer = map.get("西施");
		System.out.println("获取指定Key对应 的value：" + integer);//23

		//获取指定key对应的value，如果没key，就返回默认值
		Integer orDefault = map.getOrDefault("貂蝉111", 666);
		System.out.println("获取指定key对应的value：" + orDefault);//666

		System.out.println("判断map集合中是否不包含元素：" + map.isEmpty());//false

		//将newMap中所有的元素都添加到map中
		Hashtable<String, Integer> newMap = new Hashtable<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		map.putAll(newMap);

		//如果map中没有该key就添加，如果有就返回对应的value
		Integer putIfAbsent = map.putIfAbsent("ddd", 40);
		System.out.println("如果map中没有该key就添加，如果有就返回对应的value：" + putIfAbsent);

		//根据key删除映射关系
		map.remove("杨贵妃");
		//根据key+value删除映射关系
		map.remove("ccc", 30);

		System.out.println("获取map中映射关系的个数：" + map.size());//8

		//获取map中所有的value，返回集合
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));

		System.out.println("---------------");

		//遍历方式1 -- keySet()
		//思路：获取map中所有的key，将key存放在set集合中，遍历set集合将key取出，
		//就可以通过map获取key对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + "---" + value);
		}
		
		System.out.println("---------------");
		
		//遍历方式2 -- entrySet()
		//entry：表示映射关系（key + value）
		//思路：获取map中所有的映射关系对象，将映射关系对象存放在set集合中，遍历set集合将映射关系对象取出，
		//就可以通过映射关系对象获取到key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

五、ConcurrentHashMap

1.ConcurrentHashMap的使用

2.特点：key是唯一的

import java.util.Arrays;
import java.util.Collection;

import java.util.concurrent.ConcurrentHashMap;
import java.util.Set;
import java.util.Map.Entry;

public class Test01 {

	public static void main(String[] args) {
		
		ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
		
		//添加元素 -- 如果key是第一次添加，则返回null
		Integer  put1 = map.put("大桥",18);
		Integer  put2 = map.put("小乔",19);
		Integer  put3 = map.put("西施",25);
		Integer  put4 = map.put("王昭君",20);
		Integer  put5 = map.put("杨贵妃",23);
		Integer  put6 = map.put("貂蝉",28);
		
		System.out.println("put()的返回值：" + put1);
		System.out.println("put()的返回值：" + put2);
		System.out.println("put()的返回值：" + put3);
		System.out.println("put()的返回值：" + put4);
		System.out.println("put()的返回值：" + put5);
		System.out.println("put()的返回值：" + put6);
		
		//替换元素，返回被替换掉的值
		Integer put = map.put("大桥", 20);
		System.out.println("put()的返回值：" + put);
		
		//替换元素，返回被替换掉的值
		Integer replace = map.replace("大桥", 21);
		System.out.println("replace()的返回值" + replace);
		
		//替换元素，返回是否替换成功的boolean
		boolean bool = map.replace("西施", 25,23);
		System.out.println("替换元素，返回是否替换成功的boolean：" + bool);
		
		//清空所有元素
		//map.clear();
		
		System.out.println("判断map中是否有指定的key：" + map.containsKey("小乔"));//true
		System.out.println("判断map中是否有指定的value：" + map.containsValue(28));//true
		
		//获取指定key对应的value
		Integer integer = map.get("西施");
		System.out.println("获取指定Key对应 的value：" + integer);//23

		//获取指定key对应的value，如果没key，就返回默认值
		Integer orDefault = map.getOrDefault("貂蝉111", 666);
		System.out.println("获取指定key对应的value：" + orDefault);//666

		System.out.println("判断map集合中是否不包含元素：" + map.isEmpty());//false

		//将newMap中所有的元素都添加到map中
		ConcurrentHashMap<String, Integer> newMap = new ConcurrentHashMap<>();
		newMap.put("aaa", 10);
		newMap.put("bbb", 20);
		newMap.put("ccc", 30);
		map.putAll(newMap);

		//如果map中没有该key就添加，如果有就返回对应的value
		Integer putIfAbsent = map.putIfAbsent("ddd", 40);
		System.out.println("如果map中没有该key就添加，如果有就返回对应的value：" + putIfAbsent);

		//根据key删除映射关系
		map.remove("杨贵妃");
		//根据key+value删除映射关系
		map.remove("ccc", 30);

		System.out.println("获取map中映射关系的个数：" + map.size());//8

		//获取map中所有的value，返回集合
		Collection<Integer> values = map.values();
		System.out.println(Arrays.toString(values.toArray()));

		System.out.println("---------------");

		//遍历方式1 -- keySet()
		//思路：获取map中所有的key，将key存放在set集合中，遍历set集合将key取出，
		//就可以通过map获取key对应的value
		Set<String> keySet = map.keySet();
		for (String key : keySet) {
			Integer value = map.get(key);
			System.out.println(key + "---" + value);
		}
		
		System.out.println("---------------");
		
		//遍历方式2 -- entrySet()
		//entry：表示映射关系（key + value）
		//思路：获取map中所有的映射关系对象，将映射关系对象存放在set集合中，遍历set集合将映射关系对象取出，
		//就可以通过映射关系对象获取到key和value
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			String key = entry.getKey();
			Integer value = entry.getValue();
			System.out.println(key + " -- " + value);
		}
	}
}

3.HashMap vs LinkedHashMap vs Hashtable vs ConcurrentHashMap

1.共同点：使用都是一样的
2.特点：
HashMapkey唯一无序线程不安全
LinkedHashMapkey唯一有序线程不安全
ConcurrentHashMapkey唯一无序线程安全
Hashtablekey唯一无序线程安全
3.存储null键区别：
HashMap允许
LinkedHashMap允许
Hashtable不允许报错
ConcurrentHashMap不允许报错
import java.util.concurrent.ConcurrentHashMap;

public class Test02 {

	public static void main(String[] args) {
		
		ConcurrentHashMap<Object, Object> map = new ConcurrentHashMap<>();
		map.put(null, null);//报错
	}
}
4.Hashtable 和 ConcurrentHashMap的线程安全方式：
1.Hashtable加锁的方式：方法上加锁，效率低，弃用
2.ConcurrentHashMap加锁的方式：局部加锁+CAS，效率高
雨霖先森
关注
专栏目录
java中HashMap排序中实现Comparator接口
iCoding91
10-14 1710
1、通过观察Collections.sort()源码，如下： public static void sort(List list, Comparator c) { Object[] a = list.toArray(); Arrays.sort(a, (Comparator)c); ListIterator i = list.listIterat
HashMap、HashTable、LinkedHashMap、TreeMap、Concurrenthashmap、SparseArray
shiningdreamercaihua的博客
11-05 276
一、HashMap：(无序 ， 非并发类，不支持多线程访问， 链表的数组，拥有数组和链表的优点 允许设置空的key和value) **1、实现原理：**链表+数组 （链地址法bucket） 2、HashMap 的核心算法-hash 函数的实现（高性能需要保证以下几点）： （1）hash 算法必须是高效的 （2）hash 值到内存地址（数组索引）的算法是快速的 （3）根据内存地址（数组索引）可以...
Comparator比较器 Comparable接口 Map集合
weixin_51621893的博客
12-04 513
今日内容： Comparator比较器 Comparable接口 Map集合 学习目标： 能够描述Comparable接口和Comparator接口的区别 会自定义Comparable接口和Comparator接口比较器比中的比较规则 能够说出Map集合的特点 使用Map集合添加方法保存数据 使用“键找值”的方式遍历Map集合 使用“键值对”的方式遍历Map集合 能够使用H
Map接口及其实现类（集合）
zhongs11的博客
03-02 964
Map接口的概念特点 Map 接口 元素是由一个一个键值对组成，键不允许重复，值允许重复，<K,V> 键值对 --HashMap 底层数据结构是哈希表，保证了元素的唯一（指的是键的唯一性），元素是无序 当键是自定义类型的时候，要想保证唯一性，就必须重写hashCode()方法和equals()方法 --LinkedHashMap 底层数据结构是哈希表和链表 哈希表保证的是元素的唯...
（java基础知识）HashMap排序，Comparator接口详解
Miss熊的专栏
03-17 660
      （java基础知识）HashMap排序，Comparator接口详解 分类： java 基础知识     对于List，可以调用Collections工具类的sort()方法，直接进行排序。HashMap，就没这么幸福了。。 其实，只要了解了Comparator这个接口之后，HashMap的排序也就不难了，无论是根据key，还是根据value排序。 这个接
Map集合&比较器Comparator
weixin_61300833的博客
09-12 913
目录 Map集合: 双列集合: Map的常用方法: Entry(K k)接口: TreeMap集合: 比较器Comparator: Map集合: java.util.Map双列集合的顶层接口，用来存储具备映射关系对象的集合接口定义 特点: 主要是使用在双列集合,即:键值对类型的数据 双列集合: 以键值对的形式进行存储数据 特点: 1. 键唯一,值可以重复,如果键重复...
HashMap、HashTable、LinkedHashMap和TreeMap及ConcurrentHashMap用法和区别
小小默：进无止境
10-14 1274
Java为数据结构中的映射定义了一个接口java.util.Map，其由诸多实现类，其中四个实现类分别是**HashMap、HashTable、LinkedHashMap和TreeMap**。 **Map用于存储键值对，根据键得到值，因此不允许键重复，值可以重复。** # **【1】定义与特性** ## **① HashMap** HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。 HashMap最多只允许一条记录的键.
25Map(LinkedHashMap、Hashtable、ConcurrentHashMap、TreeMap)、内置比较器、外置比较器、Properties、Collections
gangain的博客
03-08 784
存入null键：应用场景：HashMap：无序 + 去重LinkedHashMap：有序+去重Hashtable：无序 + 去重 + 线程安全（方法里加锁，效率低，已弃用）ConcurrentHashMap：无序+去重+线程安全（局部加锁+CAS，效率高，推荐使用）5.TreeMap（内置比较器、外置比较器;比较器接口day24介绍全）6.Properties – 配置文件类7.Collections – 集合的工具类。
Java之HashMap、Hashtable、LinkedHashMap、TreeMap、ConcurrentHashMap简单的区别
码莎拉蒂
12-21 2838
一、 HashMap 1）底层实现数组+链表+红黑树（在JDK1.8中如果链表长度大于8的时候才转换为红黑树) 2）是否线程安全不支持线程的同步，线程不安全，如需同步，可用Collections的synchronizedMap方法或者使用ConcurrentHashMap，调用这个对象的方法使HashMap具有同步的能力。 3）插入值操作过程 public synchroni...
Hashtable、HashMap、concurrentHashMap、LinkedHashMap、TreeMap
ScorpC的博客
11-05 230
一、Hashtable Hashtable继承自Dictionary类，Dictionary类是一个已经被废弃的类（见其源码中的注释）。父类都被废弃，自然而然也没人用它的子类Hashtable了。 Hashtable 的 API 都是 sychronized 的，实现线程安全的方式是在修改数据时锁住整个 Hashtable，效率低。因此是线程安全的，可以直接用在多线程环境中； 由于 Hashtable 中的所有数据都加了锁，因此性能最差； 底层采用：数组+链表实现。 初始 size 为11，扩容：.
java中HashMap,LinkedHashMap,TreeMap，HashTable的区别
12-31
本文将详细分析四种常用的`Map`实现类：`HashMap`, `LinkedHashMap`, `TreeMap`以及`HashTable`之间的区别。 #### 1. HashMap `HashMap`是一种基于哈希表实现的`Map`接口，提供了一个非同步的、允许使用`null`键和...
Java 集合学习之Map（HashMap&Hashtable&LinkedHashMap&TreeMap）
大魔王的博客
08-11 264
一、Map集合类思维导图 Map：使用键值对存储。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。 二、HashMap、Hashtable、LinkedHashMap及TreeMap区别简述 Hashmap：散列表，存储Key-Value值，继承于AbstractMap，实现Map、Cloneable、S...
HashMap、Hashtable、TreeMap、LinkedHashMap、IdentityHashMap、ConcurrentHashMap和WeakHashMap的区别
qq_36470686的博客
12-01 1392
一、Map概述 java为数据结构中的映射定义了一个接口java.util.Map;它有三个实现类,分别是HashMap、Hashtable 和TreeMap. Map是用来存储键值对的数据结构，在数组中通过数组下标来对其内容进行索引的，而在Map中，则是通过对象来进行索引，用来索引的对象叫做key，其对应的对象叫value。   二、类图   注：以下说的无序的意思是指不会记录插...
Java HashMap, LinkedHashMap, TreeMap与HashTable比较详解
在Java编程中，`HashMap`, `LinkedHashMap`, `TreeMap`, 和 `HashTable` 都是实现 `java.util.Map` 接口的容器类，用于存储键值对。它们各自有独特的特性和适用场景。 1. **HashMap**: - HashMap 是基于哈希表实现...
【C++刷题】力扣-#121-买卖股票的最佳时机
会写代码的饭桶
10-16 529
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 406
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 696
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
JavaWeb合集05-SpringBoot基础知识
最新发布
qq_57340195的博客
10-17 827
Autowrite ：自动装配，通过声明的数据类型来装配对应的bean对象。缺点，只能获取到一个相同类型的bean对象，如果有IOC容器里面有2个Bean对象，使用@Autowrite依赖注入就好报错。由于三层架构中，每一层都需要下次成来提供对应的方法，所有要new 下一次的对象，如果上一层的类名发送改变，那么上一层就需要修改对应的类名，如下。3、@Resource注解：通过它来代替@Autowrite注解，直接指定要注入的Bean对象，参数name的值就是要注入的Bean对象。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 916
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨霖先森

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值