Java 之泛型详解

news/2024/9/21 14:25:45 标签: java, 开发语言, 学习

1. 泛型是什么？

泛型是 Java 中一种强大的机制，它允许你编写可以与多种数据类型一起工作的代码，而无需在编译时指定具体的类型。这样可以提高代码的灵活性、可读性和安全性。

2. 为什么要使用泛型？

泛型可以帮助我们编写更安全、更灵活、更易于维护的代码。具体来说，它带来的优势有：

  • 类型安全： 泛型可以帮助你在编译阶段就发现类型错误，例如将字符串放入整数类型的容器中。这避免了运行时出现类型转换错误，提高了程序的稳定性和可靠性。

  • 代码重用： 泛型可以让你编写一次代码，就可以适用于多种数据类型。例如，我们可以编写一个通用的排序算法，它可以对任何类型的数组进行排序，而无需编写多个版本的排序算法。

  • 可读性： 泛型可以使代码更易于理解，因为你能够明确地知道容器中存放的是什么类型的对象。例如，List<String> 比 List 更能清晰地表明该列表存放的是字符串类型。

3. 泛型如何使用？

3.1 定义泛型类

java">// 定义一个泛型类，类型参数为 T
public class GenericClass<T> {
    private T data;

    // 构造函数
    public GenericClass(T data) {
        this.data = data;
    }

    // 获取数据的方法
    public T getData() {
        return data;
    }
}

3.2 使用泛型类

java">// 使用 Integer 类型创建 GenericClass 实例
GenericClass<Integer> integerGeneric = new GenericClass<>(10);

// 使用 String 类型创建 GenericClass 实例
GenericClass<String> stringGeneric = new GenericClass<>("Hello");

// 获取数据
System.out.println("Integer data: " + integerGeneric.getData()); // 输出：Integer data: 10
System.out.println("String data: " + stringGeneric.getData()); // 输出：String data: Hello

3.3 定义泛型方法

java">public class GenericMethods {
    // 定义一个泛型方法，类型参数为 T
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

// 使用泛型方法
public static void main(String[] args) {
    Integer[] intArray = {1, 2, 3};
    String[] strArray = {"a", "b", "c"};

    // 使用泛型方法打印数组
    GenericMethods.printArray(intArray); // 输出：1 2 3
    GenericMethods.printArray(strArray); // 输出：a b c
}

4. 泛型使用场景

  • 集合类： 常见的集合类如 ArrayList、HashMap 等都使用了泛型，可以存放特定类型的对象。例如，ArrayList<String> 用于存放字符串，HashMap<String, Integer> 用于存放键值对，其中键是字符串类型，值是整数类型。

java">// 使用 ArrayList 存储字符串
List<String> names = new ArrayList<>();
names.add("John");
names.add("Jane");
names.add("Peter");

// 使用 HashMap 存储键值对
Map<String, Integer> ages = new HashMap<>();
ages.put("John", 30);
ages.put("Jane", 25);
ages.put("Peter", 28);

  • 工具类： 泛型可以用来编写通用的工具类，例如数据转换、比较等。例如，我们可以编写一个通用的排序算法，它可以对任何类型的数组进行排序，而无需编写多个版本的排序算法。

java">public class SortUtils {
    public static <T extends Comparable<T>> void sort(T[] array) {
        // 使用冒泡排序算法对数组进行排序
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j].compareTo(array[j + 1]) > 0) {
                    T temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

  • 自定义数据结构： 在实现自定义数据结构时，可以使用泛型来提高代码的可读性和可维护性。例如，我们可以使用泛型来实现一个简单的栈数据结构：

java">public class GenericStack<T> {
    private T[] data;
    private int top;

    public GenericStack(int capacity) {
        this.data = (T[]) new Object[capacity];
        this.top = -1;
    }

    public void push(T element) {
        if (top == data.length - 1) {
            throw new StackOverflowError();
        }
        data[++top] = element;
    }

    public T pop() {
        if (top == -1) {
            throw new EmptyStackException();
        }
        return data[top--];
    }

    public T peek() {
        if (top == -1) {
            throw new EmptyStackException();
        }
        return data[top];
    }

    public boolean isEmpty() {
        return top == -1;
    }
}

5. 泛型的好处

  • 类型安全: 泛型可以帮助我们在编译阶段就发现类型错误，例如将字符串放入整数类型的容器中。这避免了运行时出现类型转换错误，提高了程序的稳定性和可靠性。因为在编译阶段就能发现类型错误，所以可以避免运行时出现异常，使得程序更加稳定。

  • 代码重用: 泛型可以让你编写一次代码，就可以适用于多种数据类型。例如，我们可以编写一个通用的排序算法，它可以对任何类型的数组进行排序，而无需编写多个版本的排序算法。这使得代码更简洁，更容易维护，也减少了重复代码。

  • 可读性: 泛型可以使代码更易于理解，因为你能够明确地知道容器中存放的是什么类型的对象。例如，List<String> 比 List 更能清晰地表明该列表存放的是字符串类型。这使得代码更容易被理解和维护。

  • 代码维护性: 由于泛型可以有效地提高代码的可读性和可维护性，因此可以减少代码的维护成本。

6. 泛型特点

  • 类型参数可以是任何类型，包括基本数据类型和自定义类型。

  • 类型参数只能在类定义和方法定义中使用。

  • 编译器会对泛型代码进行类型检查，确保类型安全。

  • 泛型类型擦除： 在编译过程中，泛型类型会被擦除，这意味着在运行时，泛型类型信息将不可用。

7. 泛型应用示例

7.1 编写一个简单的泛型 Pair 类

java">public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public static void main(String[] args) {
        // 创建一个字符串键值对
        Pair<String, String> stringPair = new Pair<>("name", "John Doe");
        System.out.println("Key: " + stringPair.getKey() + ", Value: " + stringPair.getValue());

        // 创建一个整数键值对
        Pair<Integer, Integer> integerPair = new Pair<>(1, 2);
        System.out.println("Key: " + integerPair.getKey() + ", Value: " + integerPair.getValue());
    }
}

7.2 使用泛型实现一个简单的缓存

java">import java.util.HashMap;
import java.util.Map;

public class GenericCache<K, V> {
    private Map<K, V> cache = new HashMap<>();

    public V get(K key) {
        return cache.get(key);
    }

    public void put(K key, V value) {
        cache.put(key, value);
    }

    public static void main(String[] args) {
        // 创建一个字符串缓存
        GenericCache<String, String> stringCache = new GenericCache<>();
        stringCache.put("name", "John Doe");
        System.out.println("Name: " + stringCache.get("name")); // 输出：Name: John Doe

        // 创建一个整数缓存
        GenericCache<Integer, Integer> integerCache = new GenericCache<>();
        integerCache.put(1, 2);
        System.out.println("Value: " + integerCache.get(1)); // 输出：Value: 2
    }
}

7.3 泛型方法示例

这段代码是一个泛型方法，用于根据给定的 id 在 personList 中查找并返回对应的对象。

java">/**
 * 根据给定的 ID 查找 personList 中的对象。
 *
 * @param id 要查找的对象 ID
 * @return 找到的对象，如果未找到则返回 null
 * @throws IllegalAccessException 如果访问字段时出现非法访问异常
 */
public <T> T findById(int id) throws IllegalAccessException {
    // 遍历 personList 中的每一个元素
    for (int i = 0; i < personList.size(); i++) {
        // 将当前元素强制转换为泛型 T
        T person = (T) personList.get(i);
        // 获取当前对象的类类型
        Class clazz = person.getClass();
        // 获取该类的所有字段列表
        List<Field> allFieldList = getAllField(clazz);
        
        // 遍历所有字段
        for (Field field : allFieldList) {
            // 设定字段可访问
            field.setAccessible(true);
            // 检查字段的值是否等于传入的 ID
            if (field.get(personList.get(i)).equals(id)) {
                // 找到匹配的对象，返回它
                return person;
            }
        }
    }
    // 如果没有找到，返回 null
    return null;
}

 

总结： 泛型是 Java 中一个强大的工具，它可以使你的代码更灵活、更安全、更易于阅读和维护。通过泛型，你可以编写一次代码，就可以适用于多种数据类型，从而减少代码冗余和错误。希望这篇文章能够帮助各位看官理解泛型的概念和应用，并将其应用到你的 Java 开发中。感谢各位看官的观看，下期见，谢谢~


http://www.niftyadmin.cn/n/5668934.html

相关文章

Typora安装和导入导出

Typora安装和导入导出

Typora安装和导入导出 文章目录 Typora安装和导入导出前言Typora v1.9.5Typora v1.4.7Pandoc 前言 Typora v1.9是最新版, , Typora v1.4是老版本的, 这两个选择一个即可Pandoc可以导入导出word Typora v1.9.5 Typora v1.9.rar, 提取码&#xff1a;tian按ctrl单击鼠标左键打开…
阅读更多...
基于嵌入式的智能物流柜（ 触摸屏/0.96寸oled屏）

基于嵌入式的智能物流柜（ 触摸屏/0.96寸oled屏）

演示 智能物流柜&#xff08;基础版&#xff09; 智能物流柜&#xff08;升级版&#xff09; 前言 这是本人在大二在学校接的一个简单的实验室项目&#xff0c;之前发布了一个&#xff0c;由于那是在暑假&#xff0c;家里器材有限&#xff0c;代码敲完之后&#xff0c;用面包板…
阅读更多...
Intel架构的基本知识

Intel架构的基本知识

1.字节序 CPU的字节序分为LittleEndian和BigEndian。 所谓Endian，就是多字节数据在内存中的排列方式。 例如，假设有一个整数0x11223344： LittleEndian的排列方式是，从内存的低地址开始，依次存放 0x44 0x33 0x22 0x11； BigEndian的排列方式是，从内存的低地址开始，依…
阅读更多...
World of Warcraft [CLASSIC] International translation bug

World of Warcraft [CLASSIC] International translation bug

internationalization i18n_getinternationalizationjs-CSDN博客 1&#xff09;国际化翻译不完整 Chance on melee and ranged critical strike to increase your attack power by 1262 for 10s. 2&#xff09;更新美酒节&#xff0c;服务器并发太高&#xff0c;被提出副本 Wo…
阅读更多...
list(一)

list(一)

list是可以在常数范围内在任意位置进行插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代。list的底层是双向链表结构&#xff0c;双向链表中每个元素存储在互不相关的独立节点中&#xff0c;在节点中通过指针指向 其前一个元素和后一个元素。 支持 -- 但是不支持…
阅读更多...
Redis 命令：

Redis 命令：

1.通用键命令 set key value&#xff1a;设置指定键的值。get key&#xff1a;获取指定键的值。del key [key ...]&#xff1a;删除一个或多个键。expire key seconds&#xff1a;设置键的过期时间&#xff08;以秒为单位&#xff09;。ttl key&#xff1a;查看键的剩余存活时间…
阅读更多...
来自哈佛大学，引领病理AI领域前行的人：Faisal Mahmood｜大牛专辑·24-09-21

来自哈佛大学，引领病理AI领域前行的人：Faisal Mahmood｜大牛专辑·24-09-21

小罗碎碎念 领域专家介绍&#xff1a;Faisal Mahmood 变优秀的第一步&#xff0c;是向优秀的人看齐&#xff0c;站在巨人的肩膀上才能更快的成功。所以&#xff0c;我接下来每个周末都会从国内外从事医学人工智能研究的顶级专家中挑选一位进行介绍。 第一周选中的是来自哈佛大…
阅读更多...
Prometheus架构详解

Prometheus架构详解

1 Prometheus简介 Prometheus 是一个开源的系统监控报警工具套件&#xff0c;它最初由SoundCloud开发&#xff0c;并于2016年成为CNCF&#xff08;云原生计算基金会&#xff09;托管的第二个项目&#xff08;第一个是kubernetes&#xff09;。Prometheus 以其简单高效的方式收…
阅读更多...
最新文章

Copyright @ 2022~2023