集合-Map家族
1 各实现类的特点
- HashMap:存key+value,key去重,无序,线程不安全
- LinkedHashMap:存key+value,key去重,有序,线程不安全
- Hashtable:弃用,存key+value,key去重,无序,线程安全,方法加锁-效率低
- ConcurrentHashMap:存key+value,key去重,无序,线程安全,局部加锁、CAS-效率高
- TreeMap:存key+value,针对于key进行自然排序
- Properties:配置文件
2 HashMap
2.1 HashMap的使用
package com.qf.hashmap_class;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test01 {
/**
* 知识点:HashMap的使用
*
*/
public static void main(String[] args) {
HashMap<String,Integer> map = new HashMap<>();
//添加元素
Integer put1 = map.put("小希", 28);
Integer put2 = map.put("小空", 23);
Integer put3 = map.put("小丽", 29);
Integer put4 = map.put("小光", 21);
Integer put5 = map.put("小玲", 28);
System.out.println("put1:" + put1);//null
System.out.println("put2:" + put2);//null
System.out.println("put3:" + put3);//null
System.out.println("put4:" + put4);//null
System.out.println("put5:" + put5);//null
//替换 - 如果有key就替换value,返回被替换的值
Integer put6 = map.put("小空", 24);
System.out.println("put6:" + put6);//23
//替换 - 如果有key就替换value,返回被替换的值;如果没有key就返回null
Integer replace1 = map.replace("小空", 25);
System.out.println("replace1:" + replace1);//24
//替换 -- 通过key+value替换
boolean replace2 = map.replace("小空", 25, 26);
System.out.println("replace2:" + replace2);
//将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
//如果map集合中没有相同的key,就做添加操作并返回null
Integer putIfAbsent = map.putIfAbsent("小光aaa", 22);
System.out.println("putIfAbsent:" + putIfAbsent);//null
//通过key获取value
System.out.println("通过Key获取Value:" + map.get("小希"));//28
//通过key获取value,如果可以不存在则返回默认值
System.out.println("通过Key获取Value:" + map.getOrDefault("小希1", 888));//888
System.out.println("判断集合中是否有指定的key:" + map.containsKey("小希"));//true
System.out.println("判断集合中是否有指定的value:" + map.containsValue(28));//true
System.out.println("判断集合中是否没有元素:" + map.isEmpty());//false
//根据key删除元素,返回被删除的value
Integer remove1 = map.remove("小丽");
System.out.println("remove1:" + remove1);
//根据key+value删除元素,删除成功返回true,否则返回false
boolean remove2 = map.remove("小空", 24);
System.out.println("remove2:" + remove2);//true
//获取元素个数
System.out.println("获取元素个数:" + map.size());//8
//获取map集合中所有的value
Collection<Integer> values = map.values();
System.out.println(Arrays.toString(values.toArray()));//集合->数组->字符串
//清空集合
//map.clear();
System.out.println("--------------------------------");
//遍历集合 -- keySet()
//遍历思路:keySet()将Map中所有的key获取出,放在Set集合中,遍历Set集合依次获取key,利用map.get(key)获取对应的value
Set<String> keySet = map.keySet();
for (String key : keySet) {
Integer value = map.get(key);
System.out.println(key + " -- " + value);
}
System.out.println("--------------------------------");
//遍历集合 -- entrySet()
//遍历思路:entrySet()将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);
}
}
}
2.2 HashMap的特点
package com.qf.hashmap_class;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test02 {
/**
* 知识点:HashMap的特点
*
* 特点:无序 且 key去重(唯一)
*/
public static void main(String[] args) {
HashMap<String,Integer> map = new HashMap<>();
map.put("小希", 28);
map.put("小空", 23);
map.put("小丽", 29);
map.put("小光", 21);
map.put("小康", 21);
map.put("小玲", 28);
map.put("小玲", 30);
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry : entrySet) {
System.out.println(entry);
}
}
}
2.3 HashMap的面试题
package com.qf.hashmap_class;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test03 {
/**
* 知识点:HashMap的面试题
*
* 需求:给HashMap的value排序
* 思路:
* HashMap 获取映射关系对象的Set集合 -> ArrayList对象 -> list.sort(外置比较器)
*/
public static void main(String[] args) {
HashMap<String,Integer> map = new HashMap<>();
map.put("小希", 28);
map.put("小空", 23);
map.put("小丽", 29);
map.put("小光", 21);
map.put("小康", 21);
map.put("小玲", 28);
map.put("小玲", 30);
//获取映射关系对象的集合
Set<Entry<String,Integer>> entrySet = map.entrySet();
//将Set集合转换为ArraryList集合
ArrayList<Entry<String,Integer>> list = new ArrayList<>(entrySet);
//排序
list.sort(new Comparator<Entry<String,Integer>>() {
@Override
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
return o1.getValue() - o2.getValue();
}
});
for (Entry<String, Integer> entry : list) {
System.out.println(entry);
}
}
}
3 LinkedHashMap
3.1 LinkedHashMap的使用(同HashMap)
3.2 LinkedHashMap的特点
package com.qf.linkedhashmap_class;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
public class Test02 {
/**
* 知识点:LinkedHashMap的特点
*
* 继承关系:class LinkedHashMap<K,V> extends HashMap
* 注意:LinkedHashMap在HashMap的基础上添加了双向链表
*
* 特点:有序且Key去重
*/
public static void main(String[] args) {
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("aaa", 40);
map.put("bbb", 10);
map.put("ccc", 30);
map.put("ddd", 20);
map.put("eee", 40);
map.put("eee", 50);
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry : entrySet) {
System.out.println(entry);
}
}
}
4 Hashtable
4.1 Hashtable的使用(同HashMap)
4.2 Hashtable的特点
public class Test02 {
/**
* 知识点:Hashtable的特点
*
* 特点:无序且key去重 + 线程安全(方法上加锁)
*/
public static void main(String[] args) {
Hashtable<String, Integer> map = new Hashtable<>();
map.put("aaa", 40);
map.put("bbb", 10);
map.put("ccc", 30);
map.put("ddd", 20);
map.put("eee", 40);
map.put("eee", 50);
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry : entrySet) {
System.out.println(entry);
}
}
}
5 ConcurrentHashMap
5.1 ConcurrentHashMap的使用(同HashMap)
5.2 ConcurrentHashMap的特点
package com.qf.concurrenthashmap_class;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public class Test02 {
/**
* 知识点:ConcurrentHashMap的特点
*
* 特点:无序且key去重 + 线程安全(局部加锁)
*/
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("aaa", 40);
map.put("bbb", 10);
map.put("ccc", 30);
map.put("ddd", 20);
map.put("eee", 40);
map.put("eee", 50);
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry : entrySet) {
System.out.println(entry);
}
}
}
6 TreeMap
6.1 TreeMap的使用(同HashMap)
6.2 TreeMap的特点
package com.qf.treemap_class;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class Test02 {
/**
* 知识点:TreeMap的特点
*
* 特点:针对于key进行自然排序
*/
public static void main(String[] args) {
TreeMap<String, Integer> map = new TreeMap<>();
map.put("ddd", 20);
map.put("eee", 40);
map.put("bbb", 10);
map.put("ccc", 30);
map.put("aaa", 40);
map.put("eee", 50);
Set<Entry<String,Integer>> entrySet = map.entrySet();
for (Entry<String, Integer> entry : entrySet) {
System.out.println(entry);
}
}
}
7 Properties
public class Test01 {
/**
* 知识点:Properties
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//配置文件对象
Properties properties = new Properties();
//将配置文件加载到对象中
properties.load(Test01.class.getClassLoader().getResourceAsStream("DBConfig.properties"));
//获取配置文件里的数据
String username = properties.getProperty("username");
String password = properties.getProperty("password");
System.out.println(username + " -- " + password);
}
}
7 各种集合的应用场景
标签:Map,Java,map,System,put,key,集合,println,out From: https://blog.csdn.net/weixin_47234283/article/details/139427063ArrayList:存数据,线程不安全
LinkedList:队列模式、栈模式,线程不安全
Vector:弃用,线程安全
Stack:弃用,线程安全
HashSet:去重+无序,线程不安全
LinkedHashSet:去重+有序,线程不安全
TreeSet:排序,线程不安全
HashMap:存key+value,key去重,无序,线程不安全
LinkedHashMap:存key+value,key去重,有序,线程不安全
Hashtable:弃用,存key+value,key去重,无序,线程安全,方法加锁-效率低
ConcurrentHashMap:存key+value,key去重,无序,线程安全,局部加锁、CAS-效率高
TreeMap:存key+value,针对于Key排序
Properties:配置文件