Java基础系列31-双列 Map集合、Properties集合

浅浅的花香味﹌ 2022-09-11 08:19 229阅读 0赞

### 文章目录 ###

*  一. Map集合
 *   *  1.1 创建Map集合对象并添加元素
     *  1.2 Map集合的成员方法
     *  1.3 Map集合的获取功能
 *  二.Map集合遍历
 *   *  2.1 Map集合的两种遍历方式图解
     *  2.2 Map集合的遍历之键找值
     *  2.3 Map集合的遍历之键值对对象找键和值
 *  三. HashMap集合案例
 *   *  3.1 练习1 HashMap\[String, Student\]
     *  3.2 练习2 HashMap\[Student,String\]
     *  3.3 练习3 ArrayList\[HashMap\[String,String\]\]
     *  3.4 练习4 HashMap\[String, ArrayList\]
 *  四.Properties集合
 *   *  4.1 Properties概述
     *  4.2 Properties作为Map集合的使用
     *  4.3 Properties的特殊功能
     *  4.4 Properties和IO流的结合使用
 *  参考:

# 一. Map集合 #

Map集合将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

## 1.1 创建Map集合对象并添加元素 ##

代码:

package Java_study;
    
    import java.util.HashMap;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-13
     * @remark  创建Map集合对象并添加元素
     *
     */
    
    public class map1 {
    	public static void main(String[] args) {
    		//创建集合对象
    		HashMap<String, String> map = new HashMap<>();
    		
    		//添加元素 put(K key, V value)
    		map.put("NBA001", "詹姆斯" );
    		map.put("NBA002", "杜兰特");
    		map.put("NBA001", "库里");
    		
    		//输出集合对象
    		// key为主键不可冲副，新的kv键值对会把旧的kv替换掉
    		System.out.println(map);
    	}
    
    }

测试记录:

{NBA001=库里, NBA002=杜兰特}

## 1.2 Map集合的成员方法 ##

格式:

//a.添加元素
    V put(K key,V value)
    //b.根据键删除键值对元素
    V remove(Object key)
    //c.移除所有的键值对元素
    void clear()
    //d.判断集合是否包含指定的键
    boolean containsKey(Object key)
    //e.判断集合是否包含指定的值
    boolean containsValue(Object value)
    //f.判断集合是否为空
    boolean isEmpty()
    //g.返回集合中的键值对的对数
    int size()

代码:

package Java_study;
    
    import java.util.HashMap;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-13
     * @remark  Map集合的成员方法
     *
     */
    
    public class map2 {
    	public static void main(String[] args) {
    		//创建集合对象
    		HashMap<String, String> map = new HashMap<>();
    		
    		//a. map.put() 添加元素
            /*  如果主键(K)不存在，则直接存储元素，返回null
                如果主键(K)已存在，则用新的KV替换旧的KV，并返回以前的值(V) */
    		System.out.println("-----a. map.put()添加元素------");
    	    System.out.println("put: " + map.put("张无忌","周芷若"));
    	    System.out.println("put: " + map.put("张无忌", "赵敏"));
    	    System.out.println("put: " + map);//put: {张无忌=赵敏}
    	    
    	  //b. map.remove() 根据建删除键值对元素
    	    map.put("张无忌", "赵敏");
    	    map.put("郭靖", "黄蓉");
    	    map.put("杨过", "小龙女");
    	    System.out.println("-----b. map.remove() 根据建删除键值对元素-----");
    	    System.out.println("remove: " + map.remove("郭靖"));//remove: 黄蓉
    	    System.out.println("remove: " + map.remove("郭襄"));//remove: null
    	    System.out.println("remove: " + map);//remove: {杨过=小龙女, 张无忌=赵敏}
    	    
    	  //c. map.clear() 移除所有键值对元素
            System.out.println("-----c. map.clear() 移除所有键值对元素-----");
            map.clear();
            System.out.println("clear: " + map);//clear:  {}
            
          //d. map.containsKey() 判断集合是否包含指定的建
            map.put("郭靖", "黄蓉");
            System.out.println("-----d. map.containsKey() 判断集合是否包含指定的建-----");
            System.out.println("containsKey: " + map.containsKey("郭靖"));//containsKey: true
            System.out.println("containsKey: " + map.containsKey("郭襄"));//containsKey: false
            System.out.println("containsKey: " + map);//containsKey: {郭靖=黄蓉}
            
          //f. map.isEmpty() 判断集合是否为空
            System.out.println("-----f. map.isEmpty() 判断集合是否为空-----");
            System.out.println("isEmpty: " + map.isEmpty());//isEmpty: false
            System.out.println("isEmpty: " + map);//isEmpty: {郭靖=黄蓉}
            
          //g. map.size() 返回集合中的键值对的对数
            System.out.println("-----g. map.size() 返回集合中的键值对的对数----");
            System.out.println("size: " + map.size());//size: 1
            System.out.println("size: " + map);//size: {郭靖=黄蓉}
    	}
    
    }

测试记录:

-----a. map.put()添加元素------
    put: null
    put: 周芷若
    put: {张无忌=赵敏}
    -----b. map.remove() 根据建删除键值对元素-----
    remove: 黄蓉
    remove: null
    remove: {杨过=小龙女, 张无忌=赵敏}
    -----c. map.clear() 移除所有键值对元素-----
    clear: {}
    -----d. map.containsKey() 判断集合是否包含指定的建-----
    containsKey: true
    containsKey: false
    containsKey: {郭靖=黄蓉}
    -----f. map.isEmpty() 判断集合是否为空-----
    isEmpty: false
    isEmpty: {郭靖=黄蓉}
    -----g. map.size() 返回集合中的键值对的对数----
    size: 1
    size: {郭靖=黄蓉}

## 1.3 Map集合的获取功能 ##

格式:

//根据键获取值
    V get(Object key)
    //获取所有键的集合
    Set<K> keySet()
    //获取所有值的集合
    Collection<V> values()

代码:

package Java_study;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-13
     * @remark  Map集合的获取功能
     *
     */
    
    public class map3 {
    	public static void main(String[] args) {
    		//创建集合对象
    		Map<String, String> map = new HashMap<>();
    		
    		//添加元素
    		map.put("郭靖", "黄蓉");
    		map.put("杨过", "小龙女");
    		map.put("张无忌", "赵敏");
    		
    		//a: V get(Object key):根据键获取值
    		System.out.println("----a: V get(Object key):根据键获取值");
    		System.out.println("get:" + map.get("张无忌"));//get:赵敏
    		System.out.println("get:" + map.get("张三丰"));//get:null
    		
    		//b: Set<K> keySet():获取所有键的集合
    		System.out.println("-----b: Set<K> keySet():获取所有键的集合-----");
    		Set<String> set = map.keySet();
    		for (String key : set) {
    			System.out.println(key);
    		}
    		
    		//c: Collection<V> values():获取所有值的集合
    		System.out.println("-----c: Collection<V> values():获取所有值的集合-----");
    		Collection<String> values = map.values();
    		for (String value : values) {
    			System.out.println(value);
    		}
    		
    	}
    
    }

测试记录:

----a: V get(Object key):根据键获取值
    get:赵敏
    get:null
    -----b: Set<K> keySet():获取所有键的集合-----
    杨过
    郭靖
    张无忌
    -----c: Collection<V> values():获取所有值的集合-----
    小龙女
    黄蓉
    赵敏

# 二.Map集合遍历 #

## 2.1 Map集合的两种遍历方式图解 ##

![image.png][]

## 2.2 Map集合的遍历之键找值 ##

Map集合遍历的方式1:  
 思路  
  Map看成是一个夫妻对的集合  
  A: 把所有的丈夫给集中起来  
  B: 遍历丈夫的集合，获取到每一个丈夫  
  C: 根据丈夫去找对应的妻子  
 转换  
  A: 获取所有键的集合  
  B: 遍历键的集合，获取到每一个键  
  C: 根据键去找值

代码:

package Java_study;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-13
     * @remark  Map集合遍历键找值
     *
     */
    
    public class map4 {
    	public static void main(String[] args) {
    		//创建集合对象
    		Map<String, String> map = new HashMap<>();
    		
    		//添加元素
    		map.put("郭靖", "黄蓉");
    		map.put("杨过", "小龙女");
    		map.put("张无忌", "赵敏");
    		
    		//获取所有键的集合
    		Set<String> set = map.keySet();
    		
    		//遍历键的集合，获取到每一个键
    		for (String key : set) {
    			//根据key找value
    			String value = map.get(key);
    			System.out.println("{ " + key + " = " + value + " } ");
    		}
    	}
    
    }

测试记录:

{ 杨过 = 小龙女 } 
    { 郭靖 = 黄蓉 } 
    { 张无忌 = 赵敏 }

## 2.3 Map集合的遍历之键值对对象找键和值 ##

Map集合遍历的方式2：  
 思路  
  A:获取所有结婚证的集合  
  B:遍历结婚证的集合，得到每一个结婚证  
  C:根据结婚证获取丈夫和妻子  
 转换  
  A:获取所有键值对对象的集合  
  B:遍历键值对对象的集合，得到每一个键值对对象  
  C:根据键值对对象获取键和值

代码:

package Java_study;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-13
     * @remark  Map集合遍历键值对(k, v)对象找键(k)和值(v)
     *
     */
    
    public class map5 {
    	public static void main(String[] args) {
    		//创建集合对象
    		Map<String, String> map = new HashMap<String, String>();
    		
    		//添加元素
    		map.put("郭靖", "黄蓉");
    		map.put("杨过", "小龙女");
    		map.put("张无忌", "赵敏");
    		
    		//获取所有键值对(k,v)对象的集合
    		Set<Map.Entry<String, String>> set = map.entrySet();
    		//循环键值对对象的集合，得到每一个键值对对象
    		for (Map.Entry<String, String> me : set) {
    			// 根据键值对(k,v)对象获取键(k)和值(v)
    			String key = me.getKey();
    			String value = me.getValue();
    			
    			System.out.println("{ " + key + " = " + value + " }" );
    		}
    	}
    
    }

测试记录:

{ 杨过 = 小龙女 }
    { 郭靖 = 黄蓉 }
    { 张无忌 = 赵敏 }

# 三. HashMap集合案例 #

## 3.1 练习1 HashMap\[String, Student\] ##

练习1：两种方式遍历  
HashMap<String,Student>  
 键：String 学号  
 值：Student 学生对象

**代码:**  
map\_student

package Java_study;
    
    /**
     * 
     * @author 只是甲
     * @date   2021-07-13
     * @remark 实体学生类 练习1.HashMap<String, Student>
     *
     */
    
    public class map_student {
    	private String name;
    	private int age;
    	
    	public map_student(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 String toString() {
    		return "{name='" + name + '\'' + ",age = " + age + '}' ;
    	}
    	
    
    }

map\_test1

package Java_study;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    
    /**
     * 
     * @author 只是甲
     * @date   2021-07-13
     * @remark 测试类 练习1.HashMap<String, Student>
     *
     */
    
    public class map_test1 {
    	public static void main(String[] args) {
    		//创建集合对象
    		HashMap<String, map_student> hm = new HashMap<>();
    		
    		//添加集合元素
    		hm.put("NBA001", new map_student("詹姆斯",37));
    		hm.put("NBA002", new map_student("杜兰特",32));
    		hm.put("NBA003", new map_student("库里",32));
    		
    		//遍历1 根据键(k)找值(v)
    		System.out.println("----遍历1 根据键(k)");
    		Set<String> ksSet = hm.keySet();
    		for (String key : ksSet) {
    			map_student value = hm.get(key);
    			
    			System.out.println(key + " = " + value.toString());
    		}
    		
    		//遍历2 根据键值对(k,v)对象找键(k)找值(v)
            System.out.println("-----遍历2 根据键值对(k,v)对象找键(k)找值(v)-----");
            Set<Map.Entry<String, map_student>> esSet = hm.entrySet();
            for (Map.Entry<String, map_student> me: esSet) {
            	String key = me.getKey();
            	map_student value = me.getValue();
            	
            	System.out.println(key + " = " + value.toString());
            }
    		
    		
    	}
    
    }

## 3.2 练习2 HashMap\[Student,String\] ##

练习2：任选一种方式遍历  
HashMap<Student,String>  
 键：Student 学生对象  
 值：String 学生住址  
要求  
 如果学生对象的成员变量值相同，就说明是同一个键。  
 注意重写Student类的hashCode();和equals();

**代码:**  
map\_student

package Java_study;
    
    import java.util.Objects;
    
    /**
     * 
     * @author 只是甲
     * @date   2021-07-13
     * @remark 实体学生类 练习1.HashMap<String, Student>
     *
     */
    
    public class map_student {
    	private String name;
    	private int age;
    	
    	public map_student(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 String toString() {
    		return "{name='" + name + '\'' + ",age = " + age + '}' ;
    	}
    	
        
    	@Override
    	public boolean equals(Object o) {
    		if ( this == o ) return true;
    		if ( o == null || getClass() != o.getClass()) return false;
    		map_student that = (map_student) o;
    		return age == that.age && name.equals(that.name);
    	}
    	
    	@Override
    	public int hashCode() {
    		return Objects.hash(name, age);
    	}
    	
    }

map\_test2

package Java_study;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     * @author 只是甲
     * @date   2021-07-13
     * @remark 测试类 练习2.HashMap<Student,String>
     *
     */
    
    public class map_test2 {
    	public static void main(String[] args) {
    		//创建集合对象
    		HashMap<map_student, String> hm = new HashMap<>();
    		
    		//添加集合元素
    		hm.put(new map_student("詹姆斯", 37), "NBA001");
    		hm.put(new map_student("杜兰特", 32), "NBA002");
    		hm.put(new map_student("库里", 32), "NBA003");
    		
    		//遍历1 根据键(k)找值(v)
            System.out.println("-----遍历1 根据键(k)找值(v)-----");
            Set<map_student> ksSet = hm.keySet();
            for (map_student key : ksSet) {
            	String value = hm.get(key);
            	
            	System.out.println(key.toString() + " = " + value);
            }
            
          //遍历2 根据键值对(k,v)对象找键(k)找值(v)
            System.out.println("-----遍历2 根据键值对(k,v)对象找键(k)找值(v)-----");
            Set<Map.Entry<map_student, String>> esSet = hm.entrySet();
            for (Map.Entry<map_student, String> me : esSet) {
            	map_student key = me.getKey();
            	String value = me.getValue();
            	
            	System.out.println(key.toString() + " = " + value);
            }
    		
    		
    	}
    
    }

## 3.3 练习3 ArrayList\[HashMap\[String,String\]\] ##

**需求:**  
 ArrayList集合嵌套HashMap集合并遍历。  
 定义一个ArrayList集合，它包含三个元素，每一个元素都是HashMap类型的。  
 每一个HashMap集合的键和值都是String类型的，  
**键:**  
 String 丈夫的姓名  
**值:**  
 String 妻子的姓名

**给出如下的字符串数据，请用代码实现需求:**  
 第一个HashMap集合的元素  
  孙策  大乔  
  周瑜  小乔  
 第二个HashMap集合的元素  
  郭靖  黄蓉  
  杨过  小龙女  
 第三个HashMap集合的元素  
  令狐冲  任盈盈  
  林平之  岳灵珊

代码:

package Java_study;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  练习3.ArrayList<HashMap<String,String>>
     *
     */
    public class map6 {
    	public static void main(String[] args) {
    		ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
    		//创建元素1
    		HashMap<String, String> hm1 = new HashMap<String, String>();
    		hm1.put("孙策","大乔");
    		hm1.put("周瑜", "小乔");
    		
    		//创建元素2
    		HashMap<String, String> hm2 = new HashMap<String, String>();
    		hm2.put("郭靖","黄蓉");
    		hm2.put("杨过", "小龙女");
    		
    		//创建元素3
    		HashMap<String, String> hm3 = new HashMap<String, String>();
    		hm3.put("令狐冲","任盈盈");
    		hm3.put("林平之", "岳灵珊");
    		
    		//把元素添加到arrayList中
    		arrayList.add(hm1);
    		arrayList.add(hm2);
    		arrayList.add(hm3);
    		
    		//遍历ArrayList集合 aList.for
    		for (HashMap<String, String> hm : arrayList) {
    			System.out.println(hm);
    		}
    	}
    
    }

测试记录:

{孙策=大乔, 周瑜=小乔}
    {杨过=小龙女, 郭靖=黄蓉}
    {令狐冲=任盈盈, 林平之=岳灵珊}

## 3.4 练习4 HashMap\[String, ArrayList\] ##

**需求:**  
 HashMap集合嵌套ArrayList集合并遍历。  
 定义一个HashMap集合，它包含三个元素，每一个元素的键是String类型，值是ArrayList类型。  
**键:**  
 String 人物来自哪部电视剧  
**值:**  
 ArrayList 人物的名称  
 每一个ArrayList集合的数据是String类型的  
**给出如下的字符串数据，请用代码实现需求:**  
 第一个ArrayList集合的元素：(三国演义)  
  诸葛亮  
  赵云  
 第二个ArrayList集合的元素：(西游记)  
  唐僧  
  孙悟空  
 第三个ArrayList集合的元素：(水浒传)  
  武松  
  鲁智深

代码:

package Java_study;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  练习4.HashMap<String, ArrayList>
     *
     */
    
    public class map7 {
    	public static void main(String[] args) {
    		//创建集合对象
    		HashMap<String, ArrayList> hm = new HashMap<>();
    		
    		//创建元素
    		ArrayList<String> arrayList1 = new ArrayList<>();
    		ArrayList<String> arrayList2 = new ArrayList<>();
    		ArrayList<String> arrayList3 = new ArrayList<>();
    		arrayList1.add("诸葛亮");
    		arrayList1.add("赵云");
    		arrayList2.add("唐僧");
    		arrayList2.add("孙悟空");
    		arrayList3.add("武松");
    		arrayList3.add("鲁智深");
    		
    		//把元素添加到集合中
    		hm.put("三国演义", arrayList1);
    		hm.put("西游记", arrayList2);
    		hm.put("水浒传", arrayList3 );
    		
    		//遍历集合
    		Set<Map.Entry<String, ArrayList>> esSet = hm.entrySet();
    		for (Map.Entry<String, ArrayList> me : esSet) {
    			String key = me.getKey();
    			ArrayList value = me.getValue();
    			for (Object o : value) {
    				System.out.print(key+" = ");
    				System.out.println(o);
    			}
    		}
    		
    	}
    
    }

测试记录:

水浒传 = 武松
    水浒传 = 鲁智深
    三国演义 = 诸葛亮
    三国演义 = 赵云
    西游记 = 唐僧
    西游记 = 孙悟空

# 四.Properties集合 #

java.util.Hashtable<K,V> 的子类  
 - java.util.Properties

## 4.1 Properties概述 ##

Properties：属性集合类，是一个可以和IO流相结合使用的集合类;  
  Properties 可保存在流中或从流中加载。属性类表中每个键及其对应值都是一个字符串;  
  Properties 没有<>,不是泛型类;  
  Properties 是Hashtable的子类，说明是一个Map集合。

## 4.2 Properties作为Map集合的使用 ##

代码:

package Java_study;
    
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  Properties作为Map集合的添加、遍历功能
     *
     */
    
    public class properties1 {
    	public static void main(String[] args) {
    		//作为Map集合使用
    		Properties prop = new Properties();
    		
    		//添加元素
    		prop.put("it001", "hello");
    		prop.put("it002", "world");
    		prop.put("it003", "java");
    		
    		System.out.println("prop:" + prop);
    		
    		Set<Object> set = prop.keySet();
    		
    		for (Object key : set){
    			Object value = prop.get(key);
    			System.out.println(value);
    		}
    	}
    
    }

测试记录:

prop:{it003=java, it002=world, it001=hello}
    java
    world
    hello

## 4.3 Properties的特殊功能 ##

Properties的特殊功能：

//1.添加元素
     public Object setProperty(String key,String value)
     //2.获取元素
     public String getProperty(String key)
     //3.获取所有的键的集合
     public Set<String> stringPropertyNames()

代码:

package Java_study;
    
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  Properties特殊功能
     *
     */
    
    public class properties2 {
    	public static void main(String[] args) {
    		
    	
    		//创建集合对象
    		Properties prop = new Properties();
    	
    		//1. 添加元素
    		prop.setProperty("张三", "30");
    		prop.setProperty("李四", "40");
    		prop.setProperty("王五", "50");
    	
    		//3.获取所有键的集合
    		Set<String> set = prop.stringPropertyNames();
    			
    		for (String key : set) {
    			//获取元素
    			String value = prop.getProperty(key);
    			System.out.println(key + "---" + value);
    		}
    	}
    }

测试记录:

王五---50
    张三---30
    李四---40

## 4.4 Properties和IO流的结合使用 ##

Properties和IO流的结合使用：

//1.把文件中的数据读取到集合中(注意：这个文件的数据必须是键值对形式）
     public void load(Reader reader)
     //2.把集合中的数据存储到文件
     public void store(Writer writer,String comments)

代码:

package Java_study;
    
    import java.io.*;
    import java.util.Properties;
    import java.util.Set;
    
    /**
     * 
     * @author  只是甲
     * @date    2021-07-14
     * @remark  Properties和IO流的结合使用
     *
     */
    
    public class properties3 {
    	public static void main(String[] args) throws IOException{
    		propLoad("E:\\prop.txt");
    		propStore("E:\\prop2.txt");
    	}
    	
    	//2.把集合中的数据存储到文件
    	private static void propStore(String file) throws IOException{
    		//创建集合
    		Properties prop = new Properties();
    		prop.setProperty("詹姆斯", "37" );
    		prop.setProperty("杜兰特", "32" );
    		prop.setProperty("库里", "32" );
    		
    		Writer w = new FileWriter(file);
    		prop.store(w, "helloworld");
    		w.close();
    	}
    	
    	//1.把文件中的数据读取到集合中(注意：这个文件的数据必须是键值对形式）
    	private static void propLoad(String file) throws IOException {
    		Properties prop = new Properties();
    		
    		Reader r = new FileReader(file);
    		prop.load(r);
    		r.close();
    		
    		System.out.println("prop:" + prop);
    		
    		Set<String> set = prop.stringPropertyNames();
    		for (String key : set) {
    			String value = prop.getProperty(key);
    			System.out.println(key + "---" + value);
    		}
    	}
    
    }

测试记录:  
![image.png][image.png 1]

# 参考: #

1.  https://blog.csdn.net/qq\_43529621/article/details/116042907

[image.png]: /images/20220828/d6998005c3fd402eabc499b3d6e9d2f1.png
[image.png 1]: /images/20220828/1dc7d3738be44b5985d0731bf4bef59f.png