Java基础（7）----Map集合

最新推荐文章于 2024-08-02 03:58:10 发布

?abc!

最新推荐文章于 2024-08-02 03:58:10 发布

阅读量492

点赞数 1

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/yyuggjggg/article/details/119788614

版权

Java基础专栏收录该内容

55 篇文章 1 订阅

订阅专栏

Map集合

Map集合概述

interface Map<K,V>  K：键的类型；V：值的类型

Map集合的特点
- 键值对映射关系
- 一个键对应一个值：成对出现，键值对(名值对)保存,每一个key对应一个value
- 键不能重复，值可以重复：保存的记录唯一，相同key的记录添加过后会替换为新的
- 元素存取无序
- Map集合容器中，所有的(key-value)都保存在Entry对象中

他的

基本方法

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素,返回被删除的键值的value值
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

@Test
	/*
	 * Map集合容器
	 * 1.成对出现，键值对(名值对)保存,每一个key对应一个value
	 * 2.保存的记录唯一，相同key的记录添加过后会替换为新的
	 * 3.Map集合容器中，所有的(key-value)都保存在Entry对象中
	 */
	public void test1(){
		//创建集合对象
		Map<String,String> cities = new HashMap<String,String>();
		//put(K key,V value)将指定的值与该映射中的指定键相关联
		cities.put("吉林省", "长春市");
		cities.put("黑龙江省", "哈尔滨市");
		cities.put("辽宁省", "沈阳市");
		//输出集合对象
		System.out.println(cities);//{辽宁省=沈阳市, 吉林省=长春市, 黑龙江省=哈尔滨市}
		//get(Object key)
		System.out.println(cities.get("吉林省"));//长春市
		//size()
		System.out.println(cities.size());//3
		//containsKey(Object key)
		System.out.println(cities.containsKey("吉林省"));//true
		//containsValue(Object value)
		System.out.println(cities.containsValue("沈阳市"));//true
        //根据键删除键值对元素，返回被删除的键值的value值
		System.out.println(cities.remove("吉林省"));//长春市
		System.out.println(cities);//{辽宁省=沈阳市, 黑龙江省=哈尔滨市}
		System.out.println(cities.isEmpty());//false
		//void   clear()移除所有的键值对元素,没有返回值
		cities.clear();
		System.out.println(cities.isEmpty());//true
	}

获取方法

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有键的集合
Collection values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

public void test1(){
		//创建集合对象
		Map<String,String> cities = new HashMap<String,String>();
		//put(K key,V value)将指定的值与该映射中的指定键相关联
		cities.put("吉林省", "长春市");
		cities.put("黑龙江省", "哈尔滨市");
		cities.put("辽宁省", "沈阳市");
		
		//Collection<V> values():获取所有值的集合
        Collection<String> values = cities.values();
        for(String value : values) {
            System.out.println(value);
        }
	}

遍历方法

都是通过增强for循环，进行遍历，只是获取值的方法不一样

方法1：

Collection values():获取所有值的集合

public void test1(){
		//创建集合对象
		Map<String,String> cities = new HashMap<String,String>();
		//put(K key,V value)将指定的值与该映射中的指定键相关联
		cities.put("吉林省", "长春市");
		cities.put("黑龙江省", "哈尔滨市");
		cities.put("辽宁省", "沈阳市");
		
		//Collection<V> values():获取所有值的集合
        Collection<String> values = cities.values();
        for(String value : values) {
            System.out.println(value);
        }
	}

方法2：

keySet()方法

public void test1(){
		//创建集合对象
		Map<String,String> cities = new HashMap<String,String>();
		//put(K key,V value)将指定的值与该映射中的指定键相关联
		cities.put("吉林省", "长春市");
		cities.put("黑龙江省", "哈尔滨市");
		cities.put("辽宁省", "沈阳市");
		
		//获取所有键的集合。用keySet()方法实现
        Set<String> keySet = cities.keySet();
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = cities.get(key);
            System.out.println("key="+key + ",value=" + value);
        }

	}

方法3：

entrySet()：获取所有键值对对象的集合

public void test1(){
		//创建集合对象
		Map<String,String> cities = new HashMap<String,String>();
		//put(K key,V value)将指定的值与该映射中的指定键相关联
		cities.put("吉林省", "长春市");
		cities.put("黑龙江省", "哈尔滨市");
		cities.put("辽宁省", "沈阳市");

		//获取所有键值对对象的集合
		Set<Entry<String,String>> ens = cities.entrySet();
		//遍历键值对对象的集合，得到每一个键值对对象
		for(Entry<String,String> en : ens){
			//根据键值对对象获取键和值
            String key = en.getKey();
            String value = en.getValue();
            System.out.println("key="+key + ",value=" + value);
		}
		
	}

HashMap()

存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

HashMap多线程开发环境下不安全的

HashTable()

用法基本上和HashMap一样

多线程开发环境下是安全的，原因是具备线程的同步锁

LinkedHashMap ：

HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashSet集合特点

哈希表和链表实现的Set接口，具有可预测的迭代次序
由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
由哈希表保证元素唯一，也就是说没有重复的元素

案例1:Map套List

@Test
	public void test3(){
		Scanner sc = new Scanner(System.in);
		Map<String,List<City>> cities = new HashMap<String,List<City>>();
		List<City> c1 = new ArrayList<City>();
		c1.add(new City("1001","长春"));
		c1.add(new City("1002","吉林"));
		c1.add(new City("1003","通化"));
		
		List<City> c2 = new ArrayList<City>();
		c2.add(new City("2001","哈尔滨"));
		c2.add(new City("2002","齐齐哈尔"));
		c2.add(new City("2003","漠河"));
		
		List<City> c3 = new ArrayList<City>();
		c3.add(new City("3001","沈阳"));
		c3.add(new City("3002","大连"));
		c3.add(new City("3003","铁岭"));
		
		cities.put("吉林省", c1);
		cities.put("黑龙江省", c2);
		cities.put("辽宁省", c3);
		
		Set<Entry<String,List<City>>> entrySet = cities.entrySet();
		String name = sc.next();
		/*自己写的垃圾方法
		for(Entry<String,List<City>> en : entrySet){
			String key = en.getKey();
			List<City> value = en.getValue();
			if("吉林省".equals(key)){
				System.out.println(value);
				break;
			}else if("黑龙江省".equals(key)){
				System.out.println(value);				
				break;
			}else if("辽宁省".equals(key)){
				System.out.println(value);
				break;
			}
		}
		*/
		if("吉林省".equals(name) || "黑龙江省".equals(name) || "辽宁省".equals(name)){
			List<City> c = cities.get(name);
			for(City city : c){
				System.out.println(city);
			}
		}else{
			System.out.println("输入的省会不存在！");
		}
	}

案例2：List套Map

1.案例题目描述:
使用集合完成功能
2.案例完成思路要求：
1）HashMap类实例化一个Map类型的对象m1，键
（String类型）和值（int型）分别用于存储员工的姓名和工
资，存入数据如下：
张三——800元；李四——1500元；王五——3000元；（15分）
2）张三的工资更改为2600元(15分)
3）为所有员工工资加薪100元；(15分)
4）创建ArrayList<HashMap<String,Employee>>;(15分)
5)封装Employee对象，Map中的key为员工姓名；(15分)
1）遍历list集合，在控制台打印员工信息。(15分)
2）要求代码每个方法都有注释。（10分）

Employee类

package Day0818am;

public class Employee {
	private String name;
	private int salary;
	public Employee(String name, int salary) {
		super();
		this.name = name;
		this.salary = salary;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Employee() {	}
	@Override
	public String toString() {
		return "Employee [name=" + name + ", salary=" + salary + "]";
	}
	
	

}

测试类

@Test
	public void test4(){
		List<Map<String,Employee>> em = new ArrayList<Map<String,Employee>>();
		Map<String,Employee> m1 = new HashMap<String,Employee>();
		m1.put("张三", new Employee("张三",800));
		m1.put("李四", new Employee("李四",1500));
		m1.put("王五", new Employee("王五",3000));
		
		em.add(m1);
		
		System.out.println(em.get(0));
		System.out.println("----------------");
		
		Employee employee = m1.get("张三");
		System.out.println(employee.getName()+"的原本工资为："+employee.getSalary());
		employee.setSalary(2600);
		System.out.println(employee.getName()+"的工资变为："+employee.getSalary());
		
		Set<Entry<String,Employee>> entrySet = m1.entrySet();
		for(Entry<String, Employee> s : entrySet){
			String name = s.getKey();
			Employee value = s.getValue();
			value.setSalary(value.getSalary()+100);
		}
		
		
		for(Map<String, Employee> l : em){
			Set<Entry<String,Employee>> entrySet2 = l.entrySet();
			for(Entry<String, Employee> s : entrySet2){
				String name = s.getKey();
				Employee value = s.getValue();
				System.out.println(name+"的工资变为："+value.getSalary());
			}
			
		}
	}