天天看点
返回

Java基础系列31-双列 Map集合、Properties集合一. Map集合二.Map集合遍历三. HashMap集合案例四.Properties集合参考:

文章目录

  • 一. 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集合的两种遍历方式图解

Java基础系列31-双列 Map集合、Properties集合一. Map集合二.Map集合遍历三. HashMap集合案例四.Properties集合参考:

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);
		}
	}

}

测试记录:

Java基础系列31-双列 Map集合、Properties集合一. Map集合二.Map集合遍历三. HashMap集合案例四.Properties集合参考:

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/116042907
java # Java基础系列 map集合 遍历集合
上一篇: Java集合系列——总序
下一篇: FPGA静态时序分析——IO口时序（Input Delay /output Delay) - 略过天涯

继续阅读