java 里map java里map数据格式

1 Map集合

Map集合概述

• Map集合是一种双列集合，每个元素包含两个数据
• Map集合的每个元素的格式：key=value(键值对元素)
• Map集合也被称为“键值对集合”

Map集合整体格式

• Collection集合的格式: [元素1,元素2,元素3…]
• Map集合的完整格式：{key1=value1 , key2=value2 , key3=value3 , …}

Map集合体系特点

• Map集合的特点都是由键决定的
• Map集合的键是无序，不重复的，无索引的，值不做要求（可以重复）
• Map集合后面重复的键对应的值会覆盖前面重复键的值
• Map集合的键值对都可以为null

Map集合实现类特点

• HashMap：元素按照键是无序，不重复，无索引，值不做要求。（与Map体系一致）
• LinkedHashMap：元素按照键是有序，不重复，无索引，值不做要求。
• TreeMap：元素按照建是排序，不重复，无索引的，值不做要求

2 Map集合常用API

方法名称	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
public V get(Object key)	根据键获取对应值
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

public static void main(String[] args) {
// 1.添加元素: 无序，不重复，无索引。
Map<String , Integer> maps = new HashMap<>();
maps.put("iphoneX",10);
maps.put("娃娃",20);
maps.put("iphoneX",100);//  Map集合后面重复的键对应的元素会覆盖前面重复的整个元素！
maps.put("huawei",100);
maps.put("生活用品",10);
maps.put("手表",10);
System.out.println(maps);
// {huawei=100, 手表=10, 生活用品=10, iphoneX=100, 娃娃=20}

// 2.清空集合
maps.clear();
System.out.println(maps);

// 3.判断集合是否为空，为空返回true ,反之！
System.out.println(maps.isEmpty());

// 4.根据键获取对应值:public V get(Object key)
Integer key = maps.get("huawei");
System.out.println(key); // 100
System.out.println(maps.get("生活用品")); // 10
System.out.println(maps.get("生活用品2")); // null

// 5.根据键删除整个元素。(删除键会返回键的值)
System.out.println(maps.remove("iphoneX")); // 100
System.out.println(maps);

// 6.判断是否包含某个键 ，包含返回true ,反之
System.out.println(maps.containsKey("娃娃"));  // true
System.out.println(maps.containsKey("娃娃2"));  // false
System.out.println(maps.containsKey("iphoneX")); // false

// 7.判断是否包含某个值。
System.out.println(maps.containsValue(100));  // true
System.out.println(maps.containsValue(10));  // true
System.out.println(maps.containsValue(22)); // false

// 8.集合的大小
System.out.println(maps.size()); // 4

3 Map集合重要API

方法名称	说明
public Set keySet()	获取全部键的集合
Collection values()	获取全部值的集合
void putAll(Map<? extends K, ? extends V> m)	将m添加到指定集合同时去除重复键（覆盖值）

// 9.获取全部键的集合：public Set<K> keySet()
Set<String> keys = maps.keySet();
System.out.println(keys);

System.out.println("------------------------------");
// 10.获取全部值的集合：Collection<V> values();
Collection<Integer> values = maps.values();
System.out.println(values);

// 11.合并其他Map集合。(拓展)
Map<String , Integer> map1 = new HashMap<>();
map1.put("java1", 1);
map1.put("java2", 100);
Map<String , Integer> map2 = new HashMap<>();
map2.put("java2", 1);
map2.put("java3", 100);
map1.putAll(map2); // 把集合map2的元素拷贝一份到map1中去
System.out.println(map1); // {java3=100, java2=1, java1=1}
System.out.println(map2); // {java3=100, java2=1}
}

4 Map遍历方式

• 方式一：键找值的方式遍历：先获取Map集合全部的键，再根据遍历键找值
• 方式二：键值对的方式遍历，把“键值对“看成一个整体，难度较大
• 方式三：JDK 1.8开始之后的新技术：Lambda表达式

4.1 键找值

// 1、键找值：第一步：先拿到集合的全部键
Set<String> keys = maps.keySet();
// 2、第二步：遍历每个键，根据键提取值
for (String key : keys) {
    int value = maps.get(key);
    System.out.println(key + "===>" + value);
}

4.2 键值对

涉及到的API

方法名称	说明
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合
K getKey()	获得键
V getValue()	获取值

// 1、把Map集合转换成Set集合
Set<Map.Entry<String, Integer>> entries = maps.entrySet();
// 2、开始遍历
for(Map.Entry<String, Integer> entry : entries){
    String key = entry.getKey();
    int value = entry.getValue();
    System.out.println(key + "====>" + value);
}

4.3 Lambda表达式

方法名称	说明
default void forEach(BiConsumer<? super K, ? super V> action)	结合lambda遍历Map集合

// 1、把Map集合转换成Set集合
maps.forEach((k, v) -> System.out.println(k + "--->" + v));

5 HashMap

• HashMap是Map里面的一个实现类。特点都是由键决定的：无序、不重复、无索引
• 没有额外需要学习的特有方法，直接使用Map里面的方法就可以了
• 如果键要存储的是自定义对象，需要重写hashCode和equals方法
• HashMap跟HashSet底层原理是一模一样的，都是哈希表结构，只是HashMap的每个元素包含两个值而已

实际上：Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已

6 LinkedHashMap

• 由键决定：有序、不重复、无索引
• 这里的有序指的是保证存储和取出的元素顺序一致
• 原理：底层数据结构是依然哈希表，只是每个键值对元素又额外的多了一个双链表的机制记录存储的顺序

7 TreeMap

• 由键决定特性：不重复、无索引、可排序
• 可排序：按照键数据的大小默认升序（有小到大）排序。只能对键排序。
• 注意：TreeMap集合是一定要排序的，可以默认排序，也可以将键按照指定的规则进行排序

TreeMap跟TreeSet一样底层原理是一样的

TreeMap集合自定义排序规则有2种

• 自定义类实现Comparable接口，重写比较规则compareTo()

public class Apple implements Comparable<Apple>{
    private String name;
    private String color;
    private double price;
    private int weight;
...
    /**
      方式一：类自定义比较规则
      o1.compareTo(o2)
     * @param o
     * @return
     */
    @Override
    public int compareTo(Apple o) {
        // 按照重量进行比较的
        return this.weight - o.weight ; // 升序，去除重量重复的元素

    }
}

• 集合自定义Comparator比较器对象，重写比较规则

// TreeMap集合自带排序。  可排序 不重复（只要大小规则一样就认为重复）  无索引
Map<Apple, String> maps2 = new TreeMap<>(new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
    	return Double.compare(o2.getPrice() , o1.getPrice()); // 按照价格降序排序！
    }
});

// Lambda表达式
Map<Apple, String> maps2 = new TreeMap<>((o1, o2) -> Double.compare(o1.getPrice(), o2.getPrice()));