Java基础之集合Map

Java基础之集合Map
在java.util包中的集合类包含了除List之外还有另一套常用集合类:Map。
Map提供了一个更通用的元素存储方法，那就是“键值对”存储。
元素对（称作“键”和“值”），其中每个键映射到一个值。
如果说数组或者集合中的某一个值是通过下标来获取，那么Map中的值就是通过对应的键来获取。
比如我们有一个要暂存一个名字是张三的数据，Map就可以供我们设置键是name，值是张三:Map<"name", "张三">
Map接口
首先也是看根接口:Map接口，这里的K就是key键，V就是value值。
Map接口中定义了通用的存(put)取(get)方法，还有一些判空isEmpty、移除键值对remove、清空clear等等。

  抽象类AbstractMap<K,V>实现了Map<K,V>接口，我们也可以通过继承AbstractMap<K,V>抽象类来实现自己的Map。

  Java内部提供了一些实现:
  HashMap:基于哈希表的Map接口实现。允许使用null键和null值。不保证映射的顺序；特别是它不保证顺序会随着时间的推移保持不变。最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。
  代码示例:
  // 创建一个HashMap
  Map<String, Integer> map = new HashMap<>();
  // 添加键值对
  map.put("One", 1);
  map.put("Two", 2);
  map.put("Three", 3);
  // 访问键值对
  int value = map.get("Two"); // 返回2
  System.out.println("Value of 'Two': " + value);
  // 检查是否包含键或值
  boolean containsKey = map.containsKey("One"); // 返回true
  boolean containsValue = map.containsValue(3); // 返回true
  System.out.println("Contains key 'One': " + containsKey);
  System.out.println("Contains value 3: " + containsValue);
  // 获取所有键的集合
  Set<String> keys = map.keySet();
  System.out.println("Keys: " + keys);
  // 获取所有值的集合
  Collection<Integer> values = map.values();
  System.out.println("Values: " + values);
  // 获取所有键值对的集合
  Set<Map.Entry<String, Integer>> entries = map.entrySet();
  for (Map.Entry<String, Integer> entry : entries) {
      System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
  }
  // 删除一个键值对
  int removedValue = map.remove("One"); // 返回1
  System.out.println("Removed value: " + removedValue);
  // 替换一个键值对
  map.replace("Two", 22);
  System.out.println("Map after replacement: " + map);
  // 如果键不存在，则添加键值对
  map.putIfAbsent("Four", 4);
  System.out.println("Map after putIfAbsent: " + map);
  // 获取键对应的值，如果键不存在，则返回默认值
  int defaultValue = map.getOrDefault("Five", 5);
  System.out.println("Default value for 'Five': " + defaultValue);
  // 检查Map是否为空
  boolean isEmpty = map.isEmpty();
  System.out.println("Is map empty? " + isEmpty);
  // 获取Map的大小
  int size = map.size();
  System.out.println("Size of map: " + size);
  // 清空Map
  map.clear();
  System.out.println("Map after clear: " + map);
  Hashtable:类似于HashMap，但是它是同步的。不允许使用null键或null值。现在已经被ConcurrentHashMap替代，因为后者提供了更好的并发性能。
  // Hashtable
  Map<String, Integer> hashtable = new Hashtable<>();
  hashtable.put("Two", 2);
  System.out.println("Hashtable: " + hashtable);

  Properties:用于处理属性文件。键和值都是字符串。项目中的配置文件一般就是这个。
  代码示例:
  // Properties
  Properties properties = new Properties();
  properties.setProperty("Three", "3");
  System.out.println("Properties: " + properties);

  LinkedHashMap:继承自HashMap，维护了插入的顺序。
  代码示例:
  // LinkedHashMap
  Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
  linkedHashMap.put("Four", 4);
  System.out.println("LinkedHashMap: " + linkedHashMap);

  IdentityHashMap:使用==而不是equals来比较键。主要用于需要保持键的身份信息的情况。
  代码示例:
  // IdentityHashMap
  Map<String, Integer> identityHashMap = new IdentityHashMap<>();
  identityHashMap.put(new String("Five"), 5);
  System.out.println("IdentityHashMap: " + identityHashMap);

  TreeMap:基于红黑树的实现，实现了SortedMap接口。可以确保键的顺序。能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
  代码示例:
  // TreeMap
  Map<String, Integer> treeMap = new TreeMap<>();
  treeMap.put("Six", 6);
  System.out.println("TreeMap: " + treeMap);

  WeakHashMap:允许键对象被垃圾回收器回收。主要用于缓存实现。
  代码示例:
  // WeakHashMap
  Map<String, Integer> weakHashMap = new WeakHashMap<>();
  weakHashMap.put("Seven", 7);
  System.out.println("WeakHashMap: " + weakHashMap);

  ConcurrentHashMap:支持高并发性的哈希表实现。允许多个线程并发访问，并且是线程安全的。
  代码示例:
  // ConcurrentHashMap
  Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
  concurrentHashMap.put("Eight", 8);
  System.out.println("ConcurrentHashMap: " + concurrentHashMap);

  EnumMap:键必须是枚举类型。它的性能比传统的HashMap要高，因为它是针对枚举类型优化的。
  代码示例:
  // EnumMap
  Map<Day, String> enumMap = new EnumMap<>(Day.class);
  enumMap.put(Day.MONDAY, "Monday");
  System.out.println("EnumMap: " + enumMap);
      }

      enum Day {
          MONDAY, TUESDAY, WEDNESDAY
      }
  }

  SortedMap:接口，不是实现，但是可以用于创建排序的映射。
  // SortedMap 示例
  SortedMap<String, Integer> sortedMap = new TreeMap<>();
  sortedMap.put("Three", 3);
  sortedMap.put("One", 1);
  sortedMap.put("Two", 2);
  // 按顺序遍历SortedMap
  System.out.println("SortedMap:");
  for (Map.Entry<String, Integer> entry : sortedMap.entrySet()) {
      System.out.println(entry.getKey() + ": " + entry.getValue());
  }

  NavigableMap:扩展了SortedMap，提供了更多的导航方法。如headMap、tailMap和subMap，这些方法允许我们获取映射的子集。
  // NavigableMap 示例
  NavigableMap<String, Integer> navigableMap = new TreeMap<>(sortedMap);
  // 使用headMap返回小于指定键的子映射
  NavigableMap<String, Integer> headMap = navigableMap.headMap("Two", true);
  System.out.println("HeadMap (<= 'Two'): " + headMap);
  // 使用tailMap返回大于等于指定键的子映射
  NavigableMap<String, Integer> tailMap = navigableMap.tailMap("Two");
  System.out.println("TailMap (>= 'Two'): " + tailMap);
  // 使用subMap返回指定范围内的子映射
  NavigableMap<String, Integer> subMap = navigableMap.subMap("One", false, "Three", true);
  System.out.println("SubMap ('One', 'Three'): " + subMap);
  // 获取第一个键和对应的值
  Map.Entry<String, Integer> firstEntry = navigableMap.firstEntry();
  System.out.println("First Entry: " + firstEntry.getKey() + ": " + firstEntry.getValue());
  // 获取最后一个键和对应的值
  Map.Entry<String, Integer> lastEntry = navigableMap.lastEntry();
  System.out.println("Last Entry: " + lastEntry.getKey() + ": " + lastEntry.getValue());


  自定义Map实现: AbstractMap提供了Map接口的基本实现，以减少实现Map接口的工作量。可以用来创建自定义Map实现
  示例:
  class CustomMap extends AbstractMap<String, Integer> {
      private Map<String, Integer> innerMap = new HashMap<>();

      @Override
      public Set<Entry<String, Integer>> entrySet() {
          return innerMap.entrySet();
      }

      public void putCustom(String key, Integer value) {
          innerMap.put(key, value);
      }
  }
  CustomMap customMap = new CustomMap();
  customMap.putCustom("One", 1);
  customMap.putCustom("Two", 2);
  System.out.println("CustomMap: " + customMap);

  最常用的就是HashMap和SetMap，其他的了解即可。

  几种遍历方法:
  for遍历:
  上面示例已经有过，可以使用keySet()方法来获取所有key列表，然后通过get(key)来获取对应的值，以实现遍历当前Map:
  // 使用keySet()遍历
  for (String key : map.keySet()) {
      System.out.println(key + " ：" + map.get(key));
  }
  // 使用entrySet()遍历
  for (Map.Entry<String, String> entry : map.entrySet()) {
      System.out.println(entry.getKey() + " ：" + entry.getValue());
  }
  迭代器遍历:
  // 使用keySet()遍历
  Iterator<String> iterator = map.keySet().iterator();
  while (iterator.hasNext()) {
      String key = iterator.next();
      System.out.println(key + "　：" + map.get(key));
  }
  // 使用entrySet()遍历
  Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
  while (iterator.hasNext()) {
      Map.Entry<String, String> entry = iterator.next();
      System.out.println(entry.getKey() + "　：" + entry.getValue());
  }

  遍历性能速度:
  entrySet遍历的速度要比keySet快
  迭代器的遍历速度要比增强for循环快， 增强for循环使用方便，但不适合处理超大量级的数据。
  END