Java_从入门到JavaEE_17

静风残云2024-05-23 21:34

Day17

一、集合（续）

1.初识Map

Map存储的元素为键值对，通常称为key-value

而key是不允许重复的

Set唯一

2.HashMap

  1. HashMap的使用

    java 复制代码 
    public class Test {
	public static void main(String[] args) {
		HashMap<String,Integer> map = new HashMap<>();
		//添加元素
		Integer put1 = map.put("aaa", 28);
		Integer put2 = map.put("bbb", 23);
		Integer put3 = map.put("nnn", 29);
		Integer put4 = map.put("ccc", 21);
		Integer put5 = map.put("ddd", 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("aaa", 24);
		System.out.println("put6：" + put6);//23
		
		//替换 - 如果有key就替换value，返回被替换的值；如果没有key就返回null
		Integer replace1 = map.replace("aaa", 25);
		System.out.println("replace1：" + replace1);//24
		
		//替换 -- 通过key+value替换
		boolean replace2 = map.replace("aaa", 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("caaa", 22);
		System.out.println("putIfAbsent：" + putIfAbsent);//null
		
		//通过key获取value
		System.out.println("通过Key获取Value：" + map.get("ddd"));//28
		
		//通过key获取value，如果可以不存在则返回默认值
		System.out.println("通过Key获取Value：" + map.getOrDefault("aaa1", 888));//888
		
		System.out.println("判断集合中是否有指定的key：" + map.containsKey("aaa"));//true
		System.out.println("判断集合中是否有指定的value：" + map.containsValue(28));//true
		System.out.println("判断集合中是否没有元素：" + map.isEmpty());//false
		
		//根据key删除元素，返回被删除的value
		Integer remove1 = map.remove("bbb");
		System.out.println("remove1：" + remove1);
		
		//根据key+value删除元素，删除成功返回true，否则返回false
		boolean remove2 = map.remove("nnn", 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. HashMap的特点

    java 复制代码 
    public class Test {
	//特点：无序且key去重(唯一)
	public static void main(String[] args) {
		HashMap<String,Integer> map = new HashMap<>();
		map.put("aaa", 28);
		map.put("bbb", 23);
		map.put("ccc", 29);
		map.put("ddd", 21);
		map.put("eee", 21);
		map.put("fff", 28);
		map.put("fff", 30);
		
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println(entry);
		}
		
	}
}

  3. 案例：给HashMap的value排序

    思路：

    HashMap 获取映射关系对象的Set集合 -> ArrayList对象 -> list.sort(外置比较器)

    java 复制代码 
    public class Test {
	public static void main(String[] args) {	
		HashMap<String,Integer> map = new HashMap<>();
		
		map.put("aaa", 28);
		map.put("bbb", 23);
		map.put("ccc", 29);
		map.put("ddd", 21);
		map.put("eee", 21);
		map.put("fff", 28);
		
		//获取映射关系对象的集合
		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

  1. LinkedHashMap的使用(与HashMap的使用基本一致替换即可)

  2. LinkedHashMap的特点

    继承关系：class LinkedHashMap<K,V> extends HashMap

    注意：LinkedHashMap在HashMap的基础上添加了双向链表

    特点：有序且Key去重

    java 复制代码 
    public class Test02 {
	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

  1. Hashtable的使用(与HashMap的使用基本一致替换即可)

  2. Hashtable的特点

    特点：无序且key去重 + 线程安全（方法上加锁）

    java 复制代码 
    public class Test {
	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

  1. ConcurrentHashMap的使用(与HashMap的使用基本一致替换即可)

  2. ConcurrentHashMap的特点

    特点：无序且key去重 + 线程安全（局部加锁）

    java 复制代码 
    public class Test {
	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.HashMap,LinkedHashMap,Hashtable,ConcurrentHashMap区别

  1. 特点的区别：
    1. HashMap：无序且去重
    2. LinkedHashMap：有序且去重
    3. Hashtable：无序且去重 + 线程安全（方法上加锁，已弃用）
    4. ConcurrentHashMap：无序且去重 + 线程安全（局部加锁+CAS，效率更高）
  2. 存储null键null值的区别：
    1. HashMap：ok
    2. LinkedHashMap：ok
    3. Hashtable：no
    4. ConcurrentHashMap：no

7.TreeMap

  1. TreeMap的使用(与HashMap的使用基本一致替换即可)

  2. TreeMap的特点

    特点：针对于key进行自然排序

    java 复制代码 
    public class Test {
	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);
		}
	}
}

8.Properties

  1. 案例及解析

    java 复制代码 
    import java.io.IOException;
import java.util.Properties;
public class Test {
	public static void main(String[] args) throws IOException {
		//配置文件对象
		Properties properties = new Properties();	
		//将配置文件加载到对象中
        properties.load(Test.class.getClassLoader(). getResourceAsStream("DBConfig.properties"));//找到创建的DBConfig.properties文件
		//获取配置文件里的数据
		String username = properties.getProperty("username");
		String password = properties.getProperty("password");
		System.out.println(username + " -- " + password);
	}
}

9.Collections集合工具类

  1. 案例及解析

    java 复制代码 
    public class Test {
	public static void main(String[] args) {	
		ArrayList<Integer> list = new ArrayList<>();	
		//批量添加
		Collections.addAll(list, 5,8,3,4,1,2,7,9,6);		
		//排序 -- 内置比较器（按照元素所属类的排序规则）
		Collections.sort(list);		
		//注意：查找之前必须先排序
		int index = Collections.binarySearch(list, 3);
		System.out.println("获取元素的下标：" + index);		
		//排序 -- 外置比较器
		Collections.sort(list, new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o2-o1;
			}
		});		
		Integer max = Collections.max(list);
		System.out.println("最大值：" + max);		
		Integer min = Collections.min(list);
		System.out.println("最小值：" + min);		
		//替换所有元素
		Collections.fill(list, 888);		
		//获取线程安全的List集合
		List<Integer> synchronizedList = Collections.synchronizedList(list);	
		//[888, 888, 888, 888, 888, 888, 888, 888, 888]
		System.out.println(Arrays.toString(synchronizedList.toArray()));
	}
}

10.EnumSet

  1. 可以存储枚举的Set集合

  2. 案例：

    java 复制代码 
    public class Test {
	public static void main(String[] args) {		
		//Set集合中存储了Signal的对象
		EnumSet<Signal> set = EnumSet.allOf(Signal.class);		
		set.remove(Signal.RED);		
		Iterator<Signal> it = set.iterator();
		while(it.hasNext()){
			Signal next = it.next();
			System.out.println(next);
		}
	}
}
public enum Signal {
	RED, YELLOW, GREEN;
}

11.EnumMap

  1. 可以存储枚举的Map集合(注意：将枚举对象存储在key的位置)

  2. 案例：

    java 复制代码 
    public class Test {
	public static void main(String[] args) {	
		EnumMap<Signal,String> map = new EnumMap<>(Signal.class);	
		map.put(Signal.RED, "红灯");
		map.put(Signal.YELLOW, "黄灯");
		map.put(Signal.GREEN, "绿灯");	
		Set<Entry<Signal,String>> entrySet = map.entrySet();
		for (Entry<Signal, String> entry : entrySet) {
			System.out.println(entry);
		}
	}
}
public enum Signal {
	RED, YELLOW, GREEN;
}
相关推荐
西猫雷婶23 分钟前
python学opencv|读取图像（二十一）使用cv2.circle()绘制圆形进阶
开发语言·python·opencv
初晴~24 分钟前
【Redis分布式锁】高并发场景下秒杀业务的实现思路（集群模式）
java·数据库·redis·分布式·后端·spring·锁
老刘莱国瑞1 小时前
STM32 与 AS608 指纹模块的调试与应用
python·物联网·阿里云
黑胡子大叔的小屋1 小时前
基于springboot的海洋知识服务平台的设计与实现
java·spring boot·毕业设计
ThisIsClark1 小时前
【后端面试总结】深入解析进程和线程的区别
java·jvm·面试
一只敲代码的猪2 小时前
Llama 3 模型系列解析（一）
大数据·python·llama
雷神乐乐2 小时前
Spring学习(一)——Sping-XML
java·学习·spring
Hello_WOAIAI2 小时前
批量将 Word 文件转换为 HTML：Python 实现指南
python·html·word
winfredzhang2 小时前
使用Python开发PPT图片提取与九宫格合并工具
python·powerpoint·提取·九宫格·照片
小林coding3 小时前
阿里云 Java 后端一面，什么难度？
java·后端·mysql·spring·阿里云
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明0719个Web前端交互式3D JavaScript框架和库08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO