美文网首页
Java基础系列31-双列 Map集合、Properties集合

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

作者: 只是甲 | 来源:发表于2021-09-14 17:52 被阅读0次

一. 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

参考:

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

相关文章

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

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

  • Java基础之Map集合

    ## Java基础之Map集合 Map集合是一种双列集合,存储形式为键值对的形式(Map集合中的键是唯一性的) 如...

  • JavaSE总结（7）Map

    Collection中的集合称为单列集合，Map中的集合称为双列集合。 一、 java.util.Map...

  • day14 Map集合

    Map集合 Map集合是双列集合， 是一种一一对应关系，就是映射，Java提供 java,util.Map接口供我...

  • java入门 -- Map接口详细介绍

    ;import java.util.HashMap;import java.util.Map; * 双列集合: *...

  • 2019-01-03

    Map集合 Map集合 1.1Map集合概念 Map集合是一种存放关系对象的对象的双列集合。 1.2Map集合的常...

  • Java基础之常用集合

    集合分为单列集合(Collection)和双列集合(Map)，先说单列集合Collection Collecti...

  • 集合详解

    Iterator:迭代器，它是Java集合的顶层接口（不包括 map 系列的集合，Map接口 是 map 系列集合...

  • 2019-01-13

    基于Map集合重点整理 Map集合 1.1Map集合概念 Map集合是一种存放关系对象的对象的双列集合。 1.2M...

  • Java - Part 6

    一、Map集合Map集合和Collection集合不一样，Map集合是双列集合，以键值对的形式存在，键不能重复，值...

网友评论

      本文标题：Java基础系列31-双列 Map集合、Properties集合

      本文链接：https://www.haomeiwen.com/subject/aeyeultx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Java基础系列31-双列 Map集合、Properties集合|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！