Java基础教程

文章36 |   阅读 18605 |   点赞0

来源：https://blog.csdn.net/u010520724/category_11240199.html

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

转x33g5p2x  于2021-12-18 转载在 其他  
字(15.0k)|赞(0)|评价(0)|浏览(520)

一. Map集合

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

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

代码:

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

测试记录:

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

1.2 Map集合的成员方法

格式:

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

代码:

  1. package Java_study;
  3. import java.util.HashMap;
  5. /**
  6.  * 
  7.  * @author  只是甲
  8.  * @date    2021-07-13
  9.  * @remark  Map集合的成员方法
  10.  *
  11.  */
  13. public class map2 {
  14. 	public static void main(String[] args) {
  15. 		//创建集合对象
  16. 		HashMap<String, String> map = new HashMap<>();
  17. 		
  18. 		//a. map.put() 添加元素
  19.         /*  如果主键(K)不存在，则直接存储元素，返回null
  20.             如果主键(K)已存在，则用新的KV替换旧的KV，并返回以前的值(V) */
  21. 		System.out.println("-----a. map.put()添加元素------");
  22. 	    System.out.println("put: " + map.put("张无忌","周芷若"));
  23. 	    System.out.println("put: " + map.put("张无忌", "赵敏"));
  24. 	    System.out.println("put: " + map);//put: {张无忌=赵敏}
  25. 	    
  26. 	  //b. map.remove() 根据建删除键值对元素
  27. 	    map.put("张无忌", "赵敏");
  28. 	    map.put("郭靖", "黄蓉");
  29. 	    map.put("杨过", "小龙女");
  30. 	    System.out.println("-----b. map.remove() 根据建删除键值对元素-----");
  31. 	    System.out.println("remove: " + map.remove("郭靖"));//remove: 黄蓉
  32. 	    System.out.println("remove: " + map.remove("郭襄"));//remove: null
  33. 	    System.out.println("remove: " + map);//remove: {杨过=小龙女, 张无忌=赵敏}
  34. 	    
  35. 	  //c. map.clear() 移除所有键值对元素
  36.         System.out.println("-----c. map.clear() 移除所有键值对元素-----");
  37.         map.clear();
  38.         System.out.println("clear: " + map);//clear:  {}
  39.         
  40.       //d. map.containsKey() 判断集合是否包含指定的建
  41.         map.put("郭靖", "黄蓉");
  42.         System.out.println("-----d. map.containsKey() 判断集合是否包含指定的建-----");
  43.         System.out.println("containsKey: " + map.containsKey("郭靖"));//containsKey: true
  44.         System.out.println("containsKey: " + map.containsKey("郭襄"));//containsKey: false
  45.         System.out.println("containsKey: " + map);//containsKey: {郭靖=黄蓉}
  46.         
  47.       //f. map.isEmpty() 判断集合是否为空
  48.         System.out.println("-----f. map.isEmpty() 判断集合是否为空-----");
  49.         System.out.println("isEmpty: " + map.isEmpty());//isEmpty: false
  50.         System.out.println("isEmpty: " + map);//isEmpty: {郭靖=黄蓉}
  51.         
  52.       //g. map.size() 返回集合中的键值对的对数
  53.         System.out.println("-----g. map.size() 返回集合中的键值对的对数----");
  54.         System.out.println("size: " + map.size());//size: 1
  55.         System.out.println("size: " + map);//size: {郭靖=黄蓉}
  56. 	}
  58. }

测试记录:

  1. -----a. map.put()添加元素------
  2. put: null
  3. put: 周芷若
  4. put: {张无忌=赵敏}
  5. -----b. map.remove() 根据建删除键值对元素-----
  6. remove: 黄蓉
  7. remove: null
  8. remove: {杨过=小龙女, 张无忌=赵敏}
  9. -----c. map.clear() 移除所有键值对元素-----
  10. clear: {}
  11. -----d. map.containsKey() 判断集合是否包含指定的建-----
  12. containsKey: true
  13. containsKey: false
  14. containsKey: {郭靖=黄蓉}
  15. -----f. map.isEmpty() 判断集合是否为空-----
  16. isEmpty: false
  17. isEmpty: {郭靖=黄蓉}
  18. -----g. map.size() 返回集合中的键值对的对数----
  19. size: 1
  20. size: {郭靖=黄蓉}

1.3 Map集合的获取功能

格式:

  1. //根据键获取值
  2. V get(Object key)
  3. //获取所有键的集合
  4. Set<K> keySet()
  5. //获取所有值的集合
  6. Collection<V> values()

代码:

  1. package Java_study;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  8. /**
  9.  * 
  10.  * @author  只是甲
  11.  * @date    2021-07-13
  12.  * @remark  Map集合的获取功能
  13.  *
  14.  */
  16. public class map3 {
  17. 	public static void main(String[] args) {
  18. 		//创建集合对象
  19. 		Map<String, String> map = new HashMap<>();
  20. 		
  21. 		//添加元素
  22. 		map.put("郭靖", "黄蓉");
  23. 		map.put("杨过", "小龙女");
  24. 		map.put("张无忌", "赵敏");
  25. 		
  26. 		//a: V get(Object key):根据键获取值
  27. 		System.out.println("----a: V get(Object key):根据键获取值");
  28. 		System.out.println("get:" + map.get("张无忌"));//get:赵敏
  29. 		System.out.println("get:" + map.get("张三丰"));//get:null
  30. 		
  31. 		//b: Set<K> keySet():获取所有键的集合
  32. 		System.out.println("-----b: Set<K> keySet():获取所有键的集合-----");
  33. 		Set<String> set = map.keySet();
  34. 		for (String key : set) {
  35. 			System.out.println(key);
  36. 		}
  37. 		
  38. 		//c: Collection<V> values():获取所有值的集合
  39. 		System.out.println("-----c: Collection<V> values():获取所有值的集合-----");
  40. 		Collection<String> values = map.values();
  41. 		for (String value : values) {
  42. 			System.out.println(value);
  43. 		}
  44. 		
  45. 	}
  47. }

测试记录:

  1. ----a: V get(Object key):根据键获取值
  2. get:赵敏
  3. get:null
  4. -----b: Set<K> keySet():获取所有键的集合-----
  5. 杨过
  6. 郭靖
  7. 张无忌
  8. -----c: Collection<V> values():获取所有值的集合-----
  9. 小龙女
  10. 黄蓉
  11. 赵敏

二.Map集合遍历

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

2.2 Map集合的遍历之键找值

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

代码:

  1. package Java_study;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. /**
  8.  * 
  9.  * @author  只是甲
  10.  * @date    2021-07-13
  11.  * @remark  Map集合遍历键找值
  12.  *
  13.  */
  15. public class map4 {
  16. 	public static void main(String[] args) {
  17. 		//创建集合对象
  18. 		Map<String, String> map = new HashMap<>();
  19. 		
  20. 		//添加元素
  21. 		map.put("郭靖", "黄蓉");
  22. 		map.put("杨过", "小龙女");
  23. 		map.put("张无忌", "赵敏");
  24. 		
  25. 		//获取所有键的集合
  26. 		Set<String> set = map.keySet();
  27. 		
  28. 		//遍历键的集合，获取到每一个键
  29. 		for (String key : set) {
  30. 			//根据key找value
  31. 			String value = map.get(key);
  32. 			System.out.println("{ " + key + " = " + value + " } ");
  33. 		}
  34. 	}
  36. }

测试记录:

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

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

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

代码:

  1. package Java_study;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. /**
  8.  * 
  9.  * @author  只是甲
  10.  * @date    2021-07-13
  11.  * @remark  Map集合遍历键值对(k, v)对象找键(k)和值(v)
  12.  *
  13.  */
  15. public class map5 {
  16. 	public static void main(String[] args) {
  17. 		//创建集合对象
  18. 		Map<String, String> map = new HashMap<String, String>();
  19. 		
  20. 		//添加元素
  21. 		map.put("郭靖", "黄蓉");
  22. 		map.put("杨过", "小龙女");
  23. 		map.put("张无忌", "赵敏");
  24. 		
  25. 		//获取所有键值对(k,v)对象的集合
  26. 		Set<Map.Entry<String, String>> set = map.entrySet();
  27. 		//循环键值对对象的集合，得到每一个键值对对象
  28. 		for (Map.Entry<String, String> me : set) {
  29. 			// 根据键值对(k,v)对象获取键(k)和值(v)
  30. 			String key = me.getKey();
  31. 			String value = me.getValue();
  32. 			
  33. 			System.out.println("{ " + key + " = " + value + " }" );
  34. 		}
  35. 	}
  37. }

测试记录:

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

三. HashMap集合案例

3.1 练习1 HashMap[String, Student]

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

代码:
map_student

  1. package Java_study;
  3. /**
  4.  * 
  5.  * @author 只是甲
  6.  * @date   2021-07-13
  7.  * @remark 实体学生类 练习1.HashMap<String, Student>
  8.  *
  9.  */
  11. public class map_student {
  12. 	private String name;
  13. 	private int age;
  14. 	
  15. 	public map_student(String name, int age) {
  16. 		this.name = name;
  17. 		this.age = age;
  18. 	}
  19. 	
  20. 	public String getName() {
  21. 		return name;
  22. 	}
  23. 	
  24. 	public void setName(String name) {
  25. 		this.name = name;
  26. 	}
  27. 	
  28. 	public int getAge() {
  29. 		return age;
  30. 	}
  31. 	
  32. 	public void setAge(int age) {
  33. 		this.age = age;
  34. 	}
  35. 	
  36. 	@Override
  37. 	public String toString() {
  38. 		return "{name='" + name + '\'' + ",age = " + age + '}' ;
  39. 	}
  40. 	
  42. }

map_test1

  1. package Java_study;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. /**
  8.  * 
  9.  * @author 只是甲
  10.  * @date   2021-07-13
  11.  * @remark 测试类 练习1.HashMap<String, Student>
  12.  *
  13.  */
  15. public class map_test1 {
  16. 	public static void main(String[] args) {
  17. 		//创建集合对象
  18. 		HashMap<String, map_student> hm = new HashMap<>();
  19. 		
  20. 		//添加集合元素
  21. 		hm.put("NBA001", new map_student("詹姆斯",37));
  22. 		hm.put("NBA002", new map_student("杜兰特",32));
  23. 		hm.put("NBA003", new map_student("库里",32));
  24. 		
  25. 		//遍历1 根据键(k)找值(v)
  26. 		System.out.println("----遍历1 根据键(k)");
  27. 		Set<String> ksSet = hm.keySet();
  28. 		for (String key : ksSet) {
  29. 			map_student value = hm.get(key);
  30. 			
  31. 			System.out.println(key + " = " + value.toString());
  32. 		}
  33. 		
  34. 		//遍历2 根据键值对(k,v)对象找键(k)找值(v)
  35.         System.out.println("-----遍历2 根据键值对(k,v)对象找键(k)找值(v)-----");
  36.         Set<Map.Entry<String, map_student>> esSet = hm.entrySet();
  37.         for (Map.Entry<String, map_student> me: esSet) {
  38.         	String key = me.getKey();
  39.         	map_student value = me.getValue();
  40.         	
  41.         	System.out.println(key + " = " + value.toString());
  42.         }
  43. 		
  44. 		
  45. 	}
  47. }

3.2 练习2 HashMap[Student,String]

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

代码:
map_student

  1. package Java_study;
  3. import java.util.Objects;
  5. /**
  6.  * 
  7.  * @author 只是甲
  8.  * @date   2021-07-13
  9.  * @remark 实体学生类 练习1.HashMap<String, Student>
  10.  *
  11.  */
  13. public class map_student {
  14. 	private String name;
  15. 	private int age;
  16. 	
  17. 	public map_student(String name, int age) {
  18. 		this.name = name;
  19. 		this.age = age;
  20. 	}
  21. 	
  22. 	public String getName() {
  23. 		return name;
  24. 	}
  25. 	
  26. 	public void setName(String name) {
  27. 		this.name = name;
  28. 	}
  29. 	
  30. 	public int getAge() {
  31. 		return age;
  32. 	}
  33. 	
  34. 	public void setAge(int age) {
  35. 		this.age = age;
  36. 	}
  37. 	
  38. 	@Override
  39. 	public String toString() {
  40. 		return "{name='" + name + '\'' + ",age = " + age + '}' ;
  41. 	}
  42. 	
  43.     
  44. 	@Override
  45. 	public boolean equals(Object o) {
  46. 		if ( this == o ) return true;
  47. 		if ( o == null || getClass() != o.getClass()) return false;
  48. 		map_student that = (map_student) o;
  49. 		return age == that.age && name.equals(that.name);
  50. 	}
  51. 	
  52. 	@Override
  53. 	public int hashCode() {
  54. 		return Objects.hash(name, age);
  55. 	}
  56. 	
  57. }

map_test2

  1. package Java_study;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. /**
  8.  * 
  9.  * @author 只是甲
  10.  * @date   2021-07-13
  11.  * @remark 测试类 练习2.HashMap<Student,String>
  12.  *
  13.  */
  15. public class map_test2 {
  16. 	public static void main(String[] args) {
  17. 		//创建集合对象
  18. 		HashMap<map_student, String> hm = new HashMap<>();
  19. 		
  20. 		//添加集合元素
  21. 		hm.put(new map_student("詹姆斯", 37), "NBA001");
  22. 		hm.put(new map_student("杜兰特", 32), "NBA002");
  23. 		hm.put(new map_student("库里", 32), "NBA003");
  24. 		
  25. 		//遍历1 根据键(k)找值(v)
  26.         System.out.println("-----遍历1 根据键(k)找值(v)-----");
  27.         Set<map_student> ksSet = hm.keySet();
  28.         for (map_student key : ksSet) {
  29.         	String value = hm.get(key);
  30.         	
  31.         	System.out.println(key.toString() + " = " + value);
  32.         }
  33.         
  34.       //遍历2 根据键值对(k,v)对象找键(k)找值(v)
  35.         System.out.println("-----遍历2 根据键值对(k,v)对象找键(k)找值(v)-----");
  36.         Set<Map.Entry<map_student, String>> esSet = hm.entrySet();
  37.         for (Map.Entry<map_student, String> me : esSet) {
  38.         	map_student key = me.getKey();
  39.         	String value = me.getValue();
  40.         	
  41.         	System.out.println(key.toString() + " = " + value);
  42.         }
  43. 		
  44. 		
  45. 	}
  47. }

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

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

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

代码:

  1. package Java_study;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  6. /**
  7.  * 
  8.  * @author  只是甲
  9.  * @date    2021-07-14
  10.  * @remark  练习3.ArrayList<HashMap<String,String>>
  11.  *
  12.  */
  13. public class map6 {
  14. 	public static void main(String[] args) {
  15. 		ArrayList<HashMap<String, String>> arrayList = new ArrayList<>();
  16. 		//创建元素1
  17. 		HashMap<String, String> hm1 = new HashMap<String, String>();
  18. 		hm1.put("孙策","大乔");
  19. 		hm1.put("周瑜", "小乔");
  20. 		
  21. 		//创建元素2
  22. 		HashMap<String, String> hm2 = new HashMap<String, String>();
  23. 		hm2.put("郭靖","黄蓉");
  24. 		hm2.put("杨过", "小龙女");
  25. 		
  26. 		//创建元素3
  27. 		HashMap<String, String> hm3 = new HashMap<String, String>();
  28. 		hm3.put("令狐冲","任盈盈");
  29. 		hm3.put("林平之", "岳灵珊");
  30. 		
  31. 		//把元素添加到arrayList中
  32. 		arrayList.add(hm1);
  33. 		arrayList.add(hm2);
  34. 		arrayList.add(hm3);
  35. 		
  36. 		//遍历ArrayList集合 aList.for
  37. 		for (HashMap<String, String> hm : arrayList) {
  38. 			System.out.println(hm);
  39. 		}
  40. 	}
  42. }

测试记录:

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

3.4 练习4 HashMap[String, ArrayList]

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

代码:

  1. package Java_study;
  3. import java.util.ArrayList;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  8. /**
  9.  * 
  10.  * @author  只是甲
  11.  * @date    2021-07-14
  12.  * @remark  练习4.HashMap<String, ArrayList>
  13.  *
  14.  */
  16. public class map7 {
  17. 	public static void main(String[] args) {
  18. 		//创建集合对象
  19. 		HashMap<String, ArrayList> hm = new HashMap<>();
  20. 		
  21. 		//创建元素
  22. 		ArrayList<String> arrayList1 = new ArrayList<>();
  23. 		ArrayList<String> arrayList2 = new ArrayList<>();
  24. 		ArrayList<String> arrayList3 = new ArrayList<>();
  25. 		arrayList1.add("诸葛亮");
  26. 		arrayList1.add("赵云");
  27. 		arrayList2.add("唐僧");
  28. 		arrayList2.add("孙悟空");
  29. 		arrayList3.add("武松");
  30. 		arrayList3.add("鲁智深");
  31. 		
  32. 		//把元素添加到集合中
  33. 		hm.put("三国演义", arrayList1);
  34. 		hm.put("西游记", arrayList2);
  35. 		hm.put("水浒传", arrayList3 );
  36. 		
  37. 		//遍历集合
  38. 		Set<Map.Entry<String, ArrayList>> esSet = hm.entrySet();
  39. 		for (Map.Entry<String, ArrayList> me : esSet) {
  40. 			String key = me.getKey();
  41. 			ArrayList value = me.getValue();
  42. 			for (Object o : value) {
  43. 				System.out.print(key+" = ");
  44. 				System.out.println(o);
  45. 			}
  46. 		}
  47. 		
  48. 	}
  50. }

测试记录:

  1. 水浒传 = 武松
  2. 水浒传 = 鲁智深
  3. 三国演义 = 诸葛亮
  4. 三国演义 = 赵云
  5. 西游记 = 唐僧
  6. 西游记 = 孙悟空

四.Properties集合

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

4.1 Properties概述

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

4.2 Properties作为Map集合的使用

代码:

  1. package Java_study;
  3. import java.util.Properties;
  4. import java.util.Set;
  6. /**
  7.  * 
  8.  * @author  只是甲
  9.  * @date    2021-07-14
  10.  * @remark  Properties作为Map集合的添加、遍历功能
  11.  *
  12.  */
  14. public class properties1 {
  15. 	public static void main(String[] args) {
  16. 		//作为Map集合使用
  17. 		Properties prop = new Properties();
  18. 		
  19. 		//添加元素
  20. 		prop.put("it001", "hello");
  21. 		prop.put("it002", "world");
  22. 		prop.put("it003", "java");
  23. 		
  24. 		System.out.println("prop:" + prop);
  25. 		
  26. 		Set<Object> set = prop.keySet();
  27. 		
  28. 		for (Object key : set){
  29. 			Object value = prop.get(key);
  30. 			System.out.println(value);
  31. 		}
  32. 	}
  34. }

测试记录:

  1. prop:{it003=java, it002=world, it001=hello}
  2. java
  3. world
  4. hello

4.3 Properties的特殊功能

Properties的特殊功能：

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

代码:

  1. package Java_study;
  3. import java.util.Properties;
  4. import java.util.Set;
  6. /**
  7.  * 
  8.  * @author  只是甲
  9.  * @date    2021-07-14
  10.  * @remark  Properties特殊功能
  11.  *
  12.  */
  14. public class properties2 {
  15. 	public static void main(String[] args) {
  16. 		
  17. 	
  18. 		//创建集合对象
  19. 		Properties prop = new Properties();
  20. 	
  21. 		//1. 添加元素
  22. 		prop.setProperty("张三", "30");
  23. 		prop.setProperty("李四", "40");
  24. 		prop.setProperty("王五", "50");
  25. 	
  26. 		//3.获取所有键的集合
  27. 		Set<String> set = prop.stringPropertyNames();
  28. 			
  29. 		for (String key : set) {
  30. 			//获取元素
  31. 			String value = prop.getProperty(key);
  32. 			System.out.println(key + "---" + value);
  33. 		}
  34. 	}
  35. }

测试记录:

  1. 王五---50
  2. 张三---30
  3. 李四---40

4.4 Properties和IO流的结合使用

Properties和IO流的结合使用：

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

代码:

  1. package Java_study;
  3. import java.io.*;
  4. import java.util.Properties;
  5. import java.util.Set;
  7. /**
  8.  * 
  9.  * @author  只是甲
  10.  * @date    2021-07-14
  11.  * @remark  Properties和IO流的结合使用
  12.  *
  13.  */
  15. public class properties3 {
  16. 	public static void main(String[] args) throws IOException{
  17. 		propLoad("E:\\prop.txt");
  18. 		propStore("E:\\prop2.txt");
  19. 	}
  20. 	
  21. 	//2.把集合中的数据存储到文件
  22. 	private static void propStore(String file) throws IOException{
  23. 		//创建集合
  24. 		Properties prop = new Properties();
  25. 		prop.setProperty("詹姆斯", "37" );
  26. 		prop.setProperty("杜兰特", "32" );
  27. 		prop.setProperty("库里", "32" );
  28. 		
  29. 		Writer w = new FileWriter(file);
  30. 		prop.store(w, "helloworld");
  31. 		w.close();
  32. 	}
  33. 	
  34. 	//1.把文件中的数据读取到集合中(注意：这个文件的数据必须是键值对形式）
  35. 	private static void propLoad(String file) throws IOException {
  36. 		Properties prop = new Properties();
  37. 		
  38. 		Reader r = new FileReader(file);
  39. 		prop.load(r);
  40. 		r.close();
  41. 		
  42. 		System.out.println("prop:" + prop);
  43. 		
  44. 		Set<String> set = prop.stringPropertyNames();
  45. 		for (String key : set) {
  46. 			String value = prop.getProperty(key);
  47. 			System.out.println(key + "---" + value);
  48. 		}
  49. 	}
  51. }

测试记录:

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/116042907

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/u010520724/article/details/120293013

内容来源于网络，如有侵权，请联系作者删除！

Javamap集合遍历集合

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com