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

2024-01-08 03:05:57

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接口是一个接口,它有多个实现类可供使用,其中最常用的实现类是HashMapTreeMapLinkedHashMap

  • 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,以此类推。这些包装类是引用类型,可以作为泛型参数来实现泛型集合的操作。

包装类基本数据类
Booleanbooolean
Bytebyte
Integerint
Shortshort
Longlong
Floatfloat
Doubledouble
Characterchar

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

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

文章来源:https://blog.csdn.net/qq_61102168/article/details/135385413
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。