书接上文，Java里的Map接口和泛型

Map接口

Map接口是Java集合中的一种数据结构，它提供了一种将键（key）映射到值（value）的方法。在Map中，每个键都是唯一的，并且可以用来检索与之关联的值。Map接口是Java集合框架中的一部分，可以通过java.util.Map包来使用。

特点

• 键值对映射：Map接口使用键值对（key-value）的方式来存储数据。每个键都与一个值相关联，通过键可以快速定位对应的值。
• 无序性：Map中的元素没有固定的顺序，即元素的存储顺序与插入顺序无关。不同的Map实现可能根据不同的规则来存储和排序元素。
• 键的唯一性：Map中的键是唯一的，每个键只能映射到一个值。如果重复插入相同的键，则后续的值会覆盖之前的值。
• 可包含空键和空值：Map接口允许键和值都是null，即空引用。

常用方法

Map接口定义了许多常用的方法，用于操作和访问键值对数据。以下是一些常见的方法：

• put(key, value)：将指定的键值对添加到Map中，如果键已存在，则覆盖原有的值。
• get(key)：根据指定的键获取对应的值。
• containsKey(key)：检查Map中是否包含指定的键。
• containsValue(value)：检查Map中是否包含指定的值。
• remove(key)：根据指定的键删除对应的键值对。
• size()：返回Map中键值对的数量。
• isEmpty()：检查Map是否为空。
• keySet()：返回包含所有键的集合。
• values()：返回包含所有值的集合。
• entrySet()：返回包含所有键值对的集合。

实现类

Map接口是一个接口，它有多个实现类可供使用，其中最常用的实现类是HashMap、TreeMap和LinkedHashMap。

• HashMap：以哈希表的形式实现Map接口，提供了快速的插入和查找操作。不保证元素的顺序。
• TreeMap：基于红黑树的实现，按照键的自然顺序或自定义顺序对元素进行排序。
• LinkedHashMap：使用双向链表维护元素的插入顺序，可以按照插入顺序或访问顺序进行迭代。

这些实现类都提供了对Map接口的完整支持，并根据具体的需求提供了不同的性能和顺序保证。

Map遍历

1.iterator迭代器遍历
2.增强for循环遍历
3.for循环遍历
4.forEach方法里用lambda表达式

public class Student {
    public static void main(String[] args) {
        Map<String, Person> map = new HashMap<String, Person>();
        Person liming = new Person("李明", "男");
        Person zhangsan = new Person("张三", "男");
        map.put("jack", liming);
        map.put("tom", zhangsan);
        //迭代器
        Iterator<String> it = map.keySet().iterator();
        while (it.hasNext()) {
            String key = it.next();
            Person value = map.get(key);
            System.out.println(key + "对应的学生姓名是:" + value.getName() + ";性别是：" + value.getSex());
        }
        System.out.println("--------------");
        //增强for
        Set<String> set = map.keySet();
        for (String obj : set) {
//            String key = (String) obj;
            Person value = map.get(obj);
            System.out.println(obj + "对应的学生姓名是:" + value.getName() + ";性别是：" + value.getSex());
        }
        System.out.println("--------------");
        //for循环
        for (int i = 0; i < map.size(); i++) {
            System.out.println(map.keySet().toArray()[i] <br/>+ "对应的学生姓名是:" + map.get(map.keySet().toArray()[i]).getName()
                    + ";性别是：" + map.get(map.keySet().toArray()[i]).getSex());
        }
        System.out.println("--------------");

        //lambda表达式,forEach方法
        map.forEach((key, value) -> System.out.println(key + "对应的学生姓名是:" + value.getName() +
                ";性别是：" + value.getSex()));
    }

}

#泛型
将对象的类型作为参数，指定到其他类或者方法上，从而保证类型转换的安全性和稳定性。本质是参数化类型。

泛型集合

在Java中，泛型集合是指具有类型参数的集合类。泛型集合允许我们在编译时指定集合中存储的元素类型，从而提供类型安全和更好的代码重用性。以下是一些常见的泛型集合类及其用法的示例：

List<E>

List<E> 是一个接口，表示一个有序的集合，可以包含重复元素。

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Alice");

System.out.println(names); // 输出: [Alice, Bob, Alice]

Set<E>

Set<E> 是一个接口，表示一个不包含重复元素的集合。

Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(2); // 重复元素不会被添加

System.out.println(numbers); // 输出: [1, 2, 3]

Iterator<E>

Iterator是一个迭代器，一种用于遍历集合元素的接口

fruits.add("Apple");
fruits.add("Banana");
fruits.add("Cherry");

Iterator<String> iterator = fruits.iterator();
while (iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println(fruit);
}

Map<K, V>

Map<K, V> 是一个接口，表示键值对的映射。

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 80);
scores.put("Charlie", 95);

System.out.println(scores.get("Alice")); // 输出: 90

Queue<E>

Queue<E> 是一个接口，表示先进先出（FIFO）的队列。

Queue<String> queue = new LinkedList<>();
queue.offer("Apple");
queue.offer("Banana");
queue.offer("Cherry");

System.out.println(queue.poll()); // 输出: Apple

Stack<E>

Stack<E> 是一个类，表示后进先出（LIFO）的栈。

Stack<String> stack = new Stack<>();
stack.push("Apple");
stack.push("Banana");
stack.push("Cherry");

System.out.println(stack.pop()); // 输出: Cherry

##泛型的指定类型
Java中的泛型不支持基本数据类型（如 int、char、boolean 等），而只支持引用类型。这是因为泛型的实现依赖于类型擦除（Type Erasure）机制，它在编译时将泛型类型擦除为原始类型。由于基本数据类型不是引用类型，无法使用类型擦除机制来处理。

为了解决这个问题，可以使用其对应的包装类作为泛型参数。例如，使用 Integer 代替 int，Double 代替 double，Boolean 代替 boolean，以此类推。这些包装类是引用类型，可以作为泛型参数来实现泛型集合的操作。

包装类	基本数据类
Boolean	booolean
Byte	byte
Integer	int
Short	short
Long	long
Float	float
Double	double
Character	char

这些示例中的泛型集合类允许我们指定特定的元素类型，从而在编译时进行类型检查，并提供了更好的代码可读性和安全性。通过使用泛型集合，我们可以更好地组织和操作数据集合，而不必担心类型转换错误或运行时异常。

希望对你有所帮助，有的话可以点赞加收藏，让更多人看到。