文章目录

  • Map：多个键值对的集合
  • 1.整体架构流程
  • 2.Map
  • 2.1常用方法
  • 2.2 遍历方式 :
  • 3.TreeMap
  • 3.1新增方法
  • 3.2 排序
  • 3.2.1.内部比较器
  • 3.2.2 外部比较器
  • 4.HashMap
  • 4.1常用方法同Map
  • 5.Hashtable
  • 5.1与HashMap区别：
  • 6.Properties :


Map：多个键值对的集合

Map的实现类包括：
HashMap
TreeMap
Hashtable
Properties

1.整体架构流程

java map容器多个key map多个key对应一个_键值对

例如：
在语言模型中，编码器和解码器都是由一个个的 Transformer 组件拼接在一起形成的。

2.Map

键值对<key,value>：映射关系，一一对应：一个key只能对应一个value
        key是唯一的,无序的   --->Set
        value值可重复的,无序的   --->Collection
        去重 : key相同,value覆盖

2.1常用方法

* V put(K key, V value)
* void clear()
* map.clear();
* boolean isEmpty()
* boolean containsKey(Object key)
* boolean containsValue(Object value)
* V get(Object key)-------返回指定键映射到的值，如果此映射不包含该键的映射，则返回null 。
* static <K, V> Map<K,V> of(K k1, V v1, K k2, V v2)-----返回包含两个映射的不可修改映射。
* V remove(Object key) ------如果存在，则从此映射中删除键的映射（可选操作）
* default V replace(K key, V value)
* default boolean replace(K key, V oldValue, V newValue)
* int size()

2.2 遍历方式 :

1.values() 获取所有键值对的值
        2.keySet() 返回所有键值对的key
        3.Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
///1.values()方法遍历map,得到value
        Collection<String> value = map.values();
        for(String values:value){
            System.out.println(values);
        }

        2.keySet()方法遍历map，得到key
        Set<Integer> keys = map.keySet();
        for(Integer key:keys){
            System.out.println(key);
        }
        ///3.Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。
        Set<Map.Entry<Integer,String>> entrys = map.entrySet();
        for(Map.Entry<Integer,String> entry:entrys){
            System.out.println(entry.getKey()+"----->"+entry.getValue());
        }

3.TreeMap

有新增方法： TreeMap<k,v> tree = new TreeMap<>();

3.1新增方法

*ceilingKey---返回大于或等于给定键的最小键，如果没有这样的键，则null 
*ceilingEntry(K key)---返回与大于或等于给定键的最小键关联的键值映射，如果没有这样的键，则null 。 
*floorKey(K key)---返回小于或等于给定键的最小键，如果没有这样的键，则null 
*floorEntry(K key)---返回小于或等于给定键的最小键，如果没有这样的键，则null 
*higherEntry(K key) ---返回与严格大于给定键的最小键关联的键值映射，如果没有这样的键，则null 。
*higherKey(K key) ---返回严格大于给定键的最小键，如果没有这样的键，则返回null 。
*lowerEntry(K key)---返回与严格小于给定键的最大键关联的键值映射，如果没有这样的键，则null 。
*lowerKey(K key)---返回严格小于给定键的最大键，如果没有这样的键，则返回null 
*firstEntry()---返回与此映射中的最小键关联的键值映射，如果映射为空，则null 。
*K firstKey()---返回此映射中当前的第一个（最低）键。
*lastEntry()---返回与此映射中最大键关联的键值映射，如果映射为空，则null 。
*lastKey()---/返回此映射中当前的最后一个（最高）键。
*pollFirstEntry()---删除并返回与此映射中最小键关联的键值映射，如果映射为空，则null 。
*pollLastEntry()---删除并返回与此映射中最大键关联的键值映射，如果映射为空，则null 。

3.2 排序

3.2.1.内部比较器
3.2.2 外部比较器
TreeMap<Double,String> tree = new TreeMap<>();
        Teacher tea = new Teacher("a","Math");
        Teacher tea2 = new Teacher("b","IT");
        TreeMap<Teacher,String> tree1 = new TreeMap<>();
        tree1.put(tea, tea.getType());
        tree1.put(tea2, tea2.getType());
        System.out.println(tree1);
        //----------内部
        TreeMap<Teacher,String> tree2 = new TreeMap<>((o1, o2)->
         o1.getType().compareTo(o2.getType()));
        tree2.put(tea, tea.getType());
        tree2.put(tea2, tea2.getType());
    }
}
class tem implements Comparator<Teacher>{

    @Override
    public int compare(Teacher o1, Teacher o2) {
        return o1.getType().compareTo(o2.getType());
    }
}
class Teacher implements Comparable<Teacher>{
    private String name;
    private String type;
    public Teacher(){}
    public Teacher(String name, String type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", type='" + type + '\'' +
                '}';
    }

    @Override
    public int compareTo(Teacher o) {
        return this.type.compareTo(o.type);
    }
}

4.HashMap

Map<Integer,String> map = new HashMap<>();

4.1常用方法同Map

Map<Integer,String> map = new HashMap<>();
        map.put(01,"a");
        map.put(02,"b");
        map.replace(01,"c");//key 不变,替换value
        System.out.println(map);
        System.out.println(map.containsKey(01));
        System.out.println(map.containsValue("c"));
        Map map1=Map.of(03,"d",04,"e");//不可变
        System.out.println(map1);
        System.out.println(map.size());
        map.replace(01,"c","g");
        System.out.println(map);

5.Hashtable

5.1与HashMap区别：

计算hash值方式不同

继承自父类

允许null键null值

线程安全/ 同步问题

初始容量

扩容机制

HashMap

java.util.AbstractMap<>

一个key只能有一个null，一个value可以多个null

不安全/不同步

初始容量16/由构造器指定

扩容临界值12（16*0.75），每次扩容为原容量2倍/由构造器指定

Hashtable

java.util.Dictionary<>

不可以

安全/同步

初始容量11/由构造器指定

每次扩容为原容量2倍+1/由构造器指定

不建议使用Hashtable。

6.Properties :

Properties类表示一组持久的属性。可以保存到流中或从流中加载。
    属性列表中的每个键及其对应的值都是一个字符串。
    
通过Properties实现从配置文件中读取键值对数据 :
    1.定义配置文件.properties,存储键值对数据
    2.java中构建Properties对象
    3.将Properties对象调用load与输入流建立联系
    4.通过getProperty根据key获取value值实现从配置文件中读取键值对数据
// 读写操作
 Properties properties = new Properties();
       properties.setProperty("1","a");
       properties.setProperty("2","b");
       properties.setProperty("3","c");
       System.out.println(properties);
       System.out.println(properties.get("1"));
       //输出流，输出（写）键值对数据到文件.properties中，store()
      OutputStream output =new BufferedOutputStream(new FileOutputStream("src//entry.properties"));
       properties.store(output,"注释");
       output.flush();
       output.close();
       ///将文件中键值对数据读到程序中，load()
       properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("entry.properties"));
       System.out.println(properties.getProperty("1"));//当前线程的properties文件

       InputStream input = new BufferedInputStream(new FileInputStream("D://2//1.properties"));
       properties.load(input);
       System.out.println(properties.getProperty("1"));